From cd2b7530f5e3e0cea2c45c39bdc9a433149c2200 Mon Sep 17 00:00:00 2001 From: grokys Date: Thu, 5 Dec 2013 21:16:06 +0100 Subject: [PATCH] Initial commit --- .gitattributes | 22 + .gitignore | 152 + Perspex.UnitTests/Perspex.UnitTests.csproj | 105 + Perspex.UnitTests/PerspexObjectTests.cs | 313 + Perspex.UnitTests/PerspexPropertyTests.cs | 92 + Perspex.UnitTests/Properties/AssemblyInfo.cs | 36 + Perspex.UnitTests/packages.config | 6 + Perspex.Windows/DrawingContext.cs | 156 + Perspex.Windows/Interop/UnmanagedMethods.cs | 488 + Perspex.Windows/Media/TextService.cs | 32 + Perspex.Windows/Perspex.Windows.csproj | 115 + Perspex.Windows/Properties/AssemblyInfo.cs | 36 + Perspex.Windows/Renderer.cs | 106 + Perspex.Windows/Threading/Dispatcher.cs | 637 + Perspex.Windows/Threading/DispatcherFrame.cs | 25 + .../Threading/DispatcherOperation.cs | 159 + Perspex.Windows/Window.cs | 149 + Perspex.Windows/packages.config | 12 + Perspex.sln | 40 + Perspex/Controls/Border.cs | 27 + Perspex/Controls/ContentControl.cs | 46 + Perspex/Controls/ContentPresenter.cs | 131 + Perspex/Controls/Control.cs | 76 + Perspex/Controls/Decorator.cs | 54 + Perspex/Controls/TemplatedControl.cs | 47 + Perspex/Controls/TextBlock.cs | 68 + Perspex/Media/Brush.cs | 15 + Perspex/Media/Color.cs | 110 + Perspex/Media/FormattedText.cs | 17 + Perspex/Media/IDrawingContext.cs | 36 + Perspex/Media/ITextService.cs | 7 + Perspex/Media/Pen.cs | 46 + Perspex/Media/SolidColorBrush.cs | 41 + Perspex/Perspex.csproj | 142 + Perspex/PerspexObject.cs | 352 + Perspex/PerspexProperty.cs | 186 + Perspex/PerspexPropertyChangedEventArgs.cs | 45 + Perspex/Point.cs | 56 + Perspex/Properties/AssemblyInfo.cs | 28 + Perspex/ReadOnlyPerspexProperty.cs | 12 + Perspex/Rect.cs | 147 + Perspex/ServiceLocator.cs | 24 + Perspex/Size.cs | 94 + Perspex/Thickness.cs | 163 + Perspex/Visual.cs | 33 + Perspex/packages.config | 9 + TestApplication/App.config | 6 + TestApplication/Program.cs | 34 + TestApplication/Properties/AssemblyInfo.cs | 36 + TestApplication/TestApplication.csproj | 98 + TestApplication/packages.config | 11 + .../Rx-Core.2.1.30214.0.nupkg | Bin 0 -> 499563 bytes .../Rx-Core.2.1.30214.0.nuspec | 25 + .../lib/Net40/System.Reactive.Core.XML | 2617 + .../lib/Net40/System.Reactive.Core.dll | Bin 0 -> 104008 bytes .../lib/Net45/System.Reactive.Core.XML | 2873 + .../lib/Net45/System.Reactive.Core.dll | Bin 0 -> 121416 bytes .../lib/NetCore45/System.Reactive.Core.XML | 2873 + .../lib/NetCore45/System.Reactive.Core.dll | Bin 0 -> 121416 bytes .../System.Reactive.Core.XML | 2873 + .../System.Reactive.Core.dll | Bin 0 -> 121416 bytes .../System.Reactive.Core.XML | 2516 + .../System.Reactive.Core.dll | Bin 0 -> 104016 bytes packages/Rx-Core.2.1.30214.0/lib/SL4/_._ | 0 .../lib/SL5/System.Reactive.Core.XML | 2617 + .../lib/SL5/System.Reactive.Core.dll | Bin 0 -> 105032 bytes .../lib/WP8/System.Reactive.Core.XML | 2873 + .../lib/WP8/System.Reactive.Core.dll | Bin 0 -> 121416 bytes .../Rx-Interfaces.2.1.30214.0.nupkg | Bin 0 -> 121888 bytes .../Rx-Interfaces.2.1.30214.0.nuspec | 21 + .../lib/Net40/System.Reactive.Interfaces.XML | 336 + .../lib/Net40/System.Reactive.Interfaces.dll | Bin 0 -> 24136 bytes .../lib/Net45/System.Reactive.Interfaces.XML | 336 + .../lib/Net45/System.Reactive.Interfaces.dll | Bin 0 -> 24136 bytes .../NetCore45/System.Reactive.Interfaces.XML | 336 + .../NetCore45/System.Reactive.Interfaces.dll | Bin 0 -> 24136 bytes .../System.Reactive.Interfaces.XML | 336 + .../System.Reactive.Interfaces.dll | Bin 0 -> 24136 bytes .../System.Reactive.Interfaces.XML | 336 + .../System.Reactive.Interfaces.dll | Bin 0 -> 24144 bytes .../Rx-Interfaces.2.1.30214.0/lib/SL4/_._ | 0 .../lib/SL5/System.Reactive.Interfaces.XML | 368 + .../lib/SL5/System.Reactive.Interfaces.dll | Bin 0 -> 24152 bytes .../lib/WP8/System.Reactive.Interfaces.XML | 336 + .../lib/WP8/System.Reactive.Interfaces.dll | Bin 0 -> 24136 bytes .../Rx-Linq.2.1.30214.0.nupkg | Bin 0 -> 1806118 bytes .../Rx-Linq.2.1.30214.0.nuspec | 26 + .../lib/Net40/System.Reactive.Linq.XML | 10510 ++++ .../lib/Net40/System.Reactive.Linq.dll | Bin 0 -> 686664 bytes .../lib/Net45/System.Reactive.Linq.XML | 10565 ++++ .../lib/Net45/System.Reactive.Linq.dll | Bin 0 -> 692296 bytes .../lib/NetCore45/System.Reactive.Linq.XML | 10565 ++++ .../lib/NetCore45/System.Reactive.Linq.dll | Bin 0 -> 692296 bytes .../System.Reactive.Linq.XML | 10565 ++++ .../System.Reactive.Linq.dll | Bin 0 -> 692296 bytes .../System.Reactive.Linq.XML | 7587 +++ .../System.Reactive.Linq.dll | Bin 0 -> 393824 bytes packages/Rx-Linq.2.1.30214.0/lib/SL4/_._ | 0 .../lib/SL5/System.Reactive.Linq.XML | 10510 ++++ .../lib/SL5/System.Reactive.Linq.dll | Bin 0 -> 687176 bytes .../lib/WP8/System.Reactive.Linq.XML | 10565 ++++ .../lib/WP8/System.Reactive.Linq.dll | Bin 0 -> 692296 bytes .../Rx-Main.2.1.30214.0.nupkg | Bin 0 -> 2753 bytes .../Rx-Main.2.1.30214.0.nuspec | 24 + .../Rx-PlatformServices.2.1.30214.0.nupkg | Bin 0 -> 152043 bytes .../Rx-PlatformServices.2.1.30214.0.nuspec | 26 + .../content/Net40/_._ | 0 .../content/Net45/_._ | 0 .../content/NetCore45/_._ | 0 .../Portable-Net45+WinRT45+WP8/Readme.txt | 16 + .../content/SL4-WindowsPhone71/_._ | 0 .../content/SL4/_._ | 0 .../content/SL5/_._ | 0 .../content/WP8/_._ | 0 .../System.Reactive.PlatformServices.XML | 378 + .../System.Reactive.PlatformServices.dll | Bin 0 -> 37448 bytes .../System.Reactive.PlatformServices.XML | 378 + .../System.Reactive.PlatformServices.dll | Bin 0 -> 37960 bytes .../System.Reactive.PlatformServices.XML | 376 + .../System.Reactive.PlatformServices.dll | Bin 0 -> 40544 bytes .../lib/Portable-Net45+WinRT45+WP8/_._ | 0 .../System.Reactive.PlatformServices.XML | 311 + .../System.Reactive.PlatformServices.dll | Bin 0 -> 40016 bytes .../lib/SL4/_._ | 0 .../SL5/System.Reactive.PlatformServices.XML | 354 + .../SL5/System.Reactive.PlatformServices.dll | Bin 0 -> 37984 bytes .../WP8/System.Reactive.PlatformServices.XML | 378 + .../WP8/System.Reactive.PlatformServices.dll | Bin 0 -> 37976 bytes packages/SharpDX.2.5.0/SharpDX.2.5.0.nupkg | Bin 0 -> 1176152 bytes packages/SharpDX.2.5.0/SharpDX.2.5.0.nuspec | 22 + packages/SharpDX.2.5.0/lib/net20/SharpDX.dll | Bin 0 -> 534528 bytes packages/SharpDX.2.5.0/lib/net20/SharpDX.xml | 46872 +++++++++++++++ packages/SharpDX.2.5.0/lib/net40/SharpDX.dll | Bin 0 -> 535040 bytes packages/SharpDX.2.5.0/lib/net40/SharpDX.xml | 46865 +++++++++++++++ packages/SharpDX.2.5.0/lib/win8/SharpDX.dll | Bin 0 -> 519168 bytes packages/SharpDX.2.5.0/lib/win8/SharpDX.xml | 47123 ++++++++++++++++ .../SharpDX.DXGI.2.5.0.nupkg | Bin 0 -> 262956 bytes .../SharpDX.DXGI.2.5.0.nuspec | 21 + .../lib/net20/SharpDX.DXGI.dll | Bin 0 -> 90112 bytes .../lib/net20/SharpDX.DXGI.xml | 4229 ++ .../lib/net40/SharpDX.DXGI.dll | Bin 0 -> 90112 bytes .../lib/net40/SharpDX.DXGI.xml | 4229 ++ .../lib/win8/SharpDX.DXGI.dll | Bin 0 -> 107008 bytes .../lib/win8/SharpDX.DXGI.xml | 6373 +++ .../SharpDX.Direct2D1.2.5.0.nupkg | Bin 0 -> 1083123 bytes .../SharpDX.Direct2D1.2.5.0.nuspec | 23 + .../lib/net20/SharpDX.Direct2D1.dll | Bin 0 -> 228864 bytes .../lib/net20/SharpDX.Direct2D1.xml | 24072 ++++++++ .../lib/net40/SharpDX.Direct2D1.dll | Bin 0 -> 229376 bytes .../lib/net40/SharpDX.Direct2D1.xml | 24072 ++++++++ .../lib/win8/SharpDX.Direct2D1.dll | Bin 0 -> 408064 bytes .../lib/win8/SharpDX.Direct2D1.xml | 42846 ++++++++++++++ packages/repositories.config | 7 + 153 files changed, 346438 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 Perspex.UnitTests/Perspex.UnitTests.csproj create mode 100644 Perspex.UnitTests/PerspexObjectTests.cs create mode 100644 Perspex.UnitTests/PerspexPropertyTests.cs create mode 100644 Perspex.UnitTests/Properties/AssemblyInfo.cs create mode 100644 Perspex.UnitTests/packages.config create mode 100644 Perspex.Windows/DrawingContext.cs create mode 100644 Perspex.Windows/Interop/UnmanagedMethods.cs create mode 100644 Perspex.Windows/Media/TextService.cs create mode 100644 Perspex.Windows/Perspex.Windows.csproj create mode 100644 Perspex.Windows/Properties/AssemblyInfo.cs create mode 100644 Perspex.Windows/Renderer.cs create mode 100644 Perspex.Windows/Threading/Dispatcher.cs create mode 100644 Perspex.Windows/Threading/DispatcherFrame.cs create mode 100644 Perspex.Windows/Threading/DispatcherOperation.cs create mode 100644 Perspex.Windows/Window.cs create mode 100644 Perspex.Windows/packages.config create mode 100644 Perspex.sln create mode 100644 Perspex/Controls/Border.cs create mode 100644 Perspex/Controls/ContentControl.cs create mode 100644 Perspex/Controls/ContentPresenter.cs create mode 100644 Perspex/Controls/Control.cs create mode 100644 Perspex/Controls/Decorator.cs create mode 100644 Perspex/Controls/TemplatedControl.cs create mode 100644 Perspex/Controls/TextBlock.cs create mode 100644 Perspex/Media/Brush.cs create mode 100644 Perspex/Media/Color.cs create mode 100644 Perspex/Media/FormattedText.cs create mode 100644 Perspex/Media/IDrawingContext.cs create mode 100644 Perspex/Media/ITextService.cs create mode 100644 Perspex/Media/Pen.cs create mode 100644 Perspex/Media/SolidColorBrush.cs create mode 100644 Perspex/Perspex.csproj create mode 100644 Perspex/PerspexObject.cs create mode 100644 Perspex/PerspexProperty.cs create mode 100644 Perspex/PerspexPropertyChangedEventArgs.cs create mode 100644 Perspex/Point.cs create mode 100644 Perspex/Properties/AssemblyInfo.cs create mode 100644 Perspex/ReadOnlyPerspexProperty.cs create mode 100644 Perspex/Rect.cs create mode 100644 Perspex/ServiceLocator.cs create mode 100644 Perspex/Size.cs create mode 100644 Perspex/Thickness.cs create mode 100644 Perspex/Visual.cs create mode 100644 Perspex/packages.config create mode 100644 TestApplication/App.config create mode 100644 TestApplication/Program.cs create mode 100644 TestApplication/Properties/AssemblyInfo.cs create mode 100644 TestApplication/TestApplication.csproj create mode 100644 TestApplication/packages.config create mode 100644 packages/Rx-Core.2.1.30214.0/Rx-Core.2.1.30214.0.nupkg create mode 100644 packages/Rx-Core.2.1.30214.0/Rx-Core.2.1.30214.0.nuspec create mode 100644 packages/Rx-Core.2.1.30214.0/lib/Net40/System.Reactive.Core.XML create mode 100644 packages/Rx-Core.2.1.30214.0/lib/Net40/System.Reactive.Core.dll create mode 100644 packages/Rx-Core.2.1.30214.0/lib/Net45/System.Reactive.Core.XML create mode 100644 packages/Rx-Core.2.1.30214.0/lib/Net45/System.Reactive.Core.dll create mode 100644 packages/Rx-Core.2.1.30214.0/lib/NetCore45/System.Reactive.Core.XML create mode 100644 packages/Rx-Core.2.1.30214.0/lib/NetCore45/System.Reactive.Core.dll create mode 100644 packages/Rx-Core.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Core.XML create mode 100644 packages/Rx-Core.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Core.dll create mode 100644 packages/Rx-Core.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Core.XML create mode 100644 packages/Rx-Core.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Core.dll create mode 100644 packages/Rx-Core.2.1.30214.0/lib/SL4/_._ create mode 100644 packages/Rx-Core.2.1.30214.0/lib/SL5/System.Reactive.Core.XML create mode 100644 packages/Rx-Core.2.1.30214.0/lib/SL5/System.Reactive.Core.dll create mode 100644 packages/Rx-Core.2.1.30214.0/lib/WP8/System.Reactive.Core.XML create mode 100644 packages/Rx-Core.2.1.30214.0/lib/WP8/System.Reactive.Core.dll create mode 100644 packages/Rx-Interfaces.2.1.30214.0/Rx-Interfaces.2.1.30214.0.nupkg create mode 100644 packages/Rx-Interfaces.2.1.30214.0/Rx-Interfaces.2.1.30214.0.nuspec create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/Net40/System.Reactive.Interfaces.XML create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/Net40/System.Reactive.Interfaces.dll create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/Net45/System.Reactive.Interfaces.XML create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/Net45/System.Reactive.Interfaces.dll create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/NetCore45/System.Reactive.Interfaces.XML create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/NetCore45/System.Reactive.Interfaces.dll create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Interfaces.XML create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Interfaces.dll create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Interfaces.XML create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Interfaces.dll create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/SL4/_._ create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/SL5/System.Reactive.Interfaces.XML create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/SL5/System.Reactive.Interfaces.dll create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/WP8/System.Reactive.Interfaces.XML create mode 100644 packages/Rx-Interfaces.2.1.30214.0/lib/WP8/System.Reactive.Interfaces.dll create mode 100644 packages/Rx-Linq.2.1.30214.0/Rx-Linq.2.1.30214.0.nupkg create mode 100644 packages/Rx-Linq.2.1.30214.0/Rx-Linq.2.1.30214.0.nuspec create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/Net40/System.Reactive.Linq.XML create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/Net40/System.Reactive.Linq.dll create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/Net45/System.Reactive.Linq.XML create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/Net45/System.Reactive.Linq.dll create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/NetCore45/System.Reactive.Linq.XML create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/NetCore45/System.Reactive.Linq.dll create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Linq.XML create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Linq.dll create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Linq.XML create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Linq.dll create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/SL4/_._ create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/SL5/System.Reactive.Linq.XML create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/SL5/System.Reactive.Linq.dll create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/WP8/System.Reactive.Linq.XML create mode 100644 packages/Rx-Linq.2.1.30214.0/lib/WP8/System.Reactive.Linq.dll create mode 100644 packages/Rx-Main.2.1.30214.0/Rx-Main.2.1.30214.0.nupkg create mode 100644 packages/Rx-Main.2.1.30214.0/Rx-Main.2.1.30214.0.nuspec create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/Rx-PlatformServices.2.1.30214.0.nupkg create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/Rx-PlatformServices.2.1.30214.0.nuspec create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/content/Net40/_._ create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/content/Net45/_._ create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/content/NetCore45/_._ create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/content/Portable-Net45+WinRT45+WP8/Readme.txt create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/content/SL4-WindowsPhone71/_._ create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/content/SL4/_._ create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/content/SL5/_._ create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/content/WP8/_._ create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/Net40/System.Reactive.PlatformServices.XML create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/Net40/System.Reactive.PlatformServices.dll create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/Net45/System.Reactive.PlatformServices.XML create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/Net45/System.Reactive.PlatformServices.dll create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/NetCore45/System.Reactive.PlatformServices.XML create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/NetCore45/System.Reactive.PlatformServices.dll create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/_._ create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.PlatformServices.XML create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.PlatformServices.dll create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/SL4/_._ create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/SL5/System.Reactive.PlatformServices.XML create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/SL5/System.Reactive.PlatformServices.dll create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/WP8/System.Reactive.PlatformServices.XML create mode 100644 packages/Rx-PlatformServices.2.1.30214.0/lib/WP8/System.Reactive.PlatformServices.dll create mode 100644 packages/SharpDX.2.5.0/SharpDX.2.5.0.nupkg create mode 100644 packages/SharpDX.2.5.0/SharpDX.2.5.0.nuspec create mode 100644 packages/SharpDX.2.5.0/lib/net20/SharpDX.dll create mode 100644 packages/SharpDX.2.5.0/lib/net20/SharpDX.xml create mode 100644 packages/SharpDX.2.5.0/lib/net40/SharpDX.dll create mode 100644 packages/SharpDX.2.5.0/lib/net40/SharpDX.xml create mode 100644 packages/SharpDX.2.5.0/lib/win8/SharpDX.dll create mode 100644 packages/SharpDX.2.5.0/lib/win8/SharpDX.xml create mode 100644 packages/SharpDX.DXGI.2.5.0/SharpDX.DXGI.2.5.0.nupkg create mode 100644 packages/SharpDX.DXGI.2.5.0/SharpDX.DXGI.2.5.0.nuspec create mode 100644 packages/SharpDX.DXGI.2.5.0/lib/net20/SharpDX.DXGI.dll create mode 100644 packages/SharpDX.DXGI.2.5.0/lib/net20/SharpDX.DXGI.xml create mode 100644 packages/SharpDX.DXGI.2.5.0/lib/net40/SharpDX.DXGI.dll create mode 100644 packages/SharpDX.DXGI.2.5.0/lib/net40/SharpDX.DXGI.xml create mode 100644 packages/SharpDX.DXGI.2.5.0/lib/win8/SharpDX.DXGI.dll create mode 100644 packages/SharpDX.DXGI.2.5.0/lib/win8/SharpDX.DXGI.xml create mode 100644 packages/SharpDX.Direct2D1.2.5.0/SharpDX.Direct2D1.2.5.0.nupkg create mode 100644 packages/SharpDX.Direct2D1.2.5.0/SharpDX.Direct2D1.2.5.0.nuspec create mode 100644 packages/SharpDX.Direct2D1.2.5.0/lib/net20/SharpDX.Direct2D1.dll create mode 100644 packages/SharpDX.Direct2D1.2.5.0/lib/net20/SharpDX.Direct2D1.xml create mode 100644 packages/SharpDX.Direct2D1.2.5.0/lib/net40/SharpDX.Direct2D1.dll create mode 100644 packages/SharpDX.Direct2D1.2.5.0/lib/net40/SharpDX.Direct2D1.xml create mode 100644 packages/SharpDX.Direct2D1.2.5.0/lib/win8/SharpDX.Direct2D1.dll create mode 100644 packages/SharpDX.Direct2D1.2.5.0/lib/win8/SharpDX.Direct2D1.xml create mode 100644 packages/repositories.config diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 000000000..412eeda78 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,22 @@ +# Auto detect text files and perform LF normalization +* text=auto + +# Custom for Visual Studio +*.cs diff=csharp +*.sln merge=union +*.csproj merge=union +*.vbproj merge=union +*.fsproj merge=union +*.dbproj merge=union + +# Standard to msysgit +*.doc diff=astextplain +*.DOC diff=astextplain +*.docx diff=astextplain +*.DOCX diff=astextplain +*.dot diff=astextplain +*.DOT diff=astextplain +*.pdf diff=astextplain +*.PDF diff=astextplain +*.rtf diff=astextplain +*.RTF diff=astextplain diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..41157decd --- /dev/null +++ b/.gitignore @@ -0,0 +1,152 @@ +################# +## Visual Studio +################# + +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. + +# User-specific files +*.suo +*.user +*.sln.docstates + +# Build results + +[Dd]ebug/ +[Rr]elease/ +x64/ +build/ +[Bb]in/ +[Oo]bj/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +*_i.c +*_p.c +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.log +*.scc + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opensdf +*.sdf +*.cachefile + +# Visual Studio profiler +*.psess +*.vsp +*.vspx + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# NCrunch +*.ncrunch* +.*crunch*.local.xml + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.Publish.xml +*.pubxml + +# NuGet Packages Directory +## TODO: If you have NuGet Package Restore enabled, uncomment the next line +#packages/ + +# Windows Azure Build Output +csx +*.build.csdef + +# Windows Store app package directory +AppPackages/ + +# Others +sql/ +*.Cache +ClientBin/ +[Ss]tyle[Cc]op.* +~$* +*~ +*.dbmdl +*.[Pp]ublish.xml +*.pfx +*.publishsettings + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file to a newer +# Visual Studio version. Backup files are not needed, because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm + +# SQL Server files +App_Data/*.mdf +App_Data/*.ldf + +############# +## Windows detritus +############# + +# Windows image file caches +Thumbs.db +ehthumbs.db + +# Folder config file +Desktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Mac crap +.DS_Store diff --git a/Perspex.UnitTests/Perspex.UnitTests.csproj b/Perspex.UnitTests/Perspex.UnitTests.csproj new file mode 100644 index 000000000..33ff73f5a --- /dev/null +++ b/Perspex.UnitTests/Perspex.UnitTests.csproj @@ -0,0 +1,105 @@ + + + + Debug + AnyCPU + {2905FF23-53FB-45E6-AA49-6AF47A172056} + Library + Properties + Perspex.UnitTests + Perspex.UnitTests + v4.5 + 512 + {3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + 10.0 + $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion) + $(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages + False + UnitTest + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + False + ..\packages\Rx-Core.2.1.30214.0\lib\Net45\System.Reactive.Core.dll + + + False + ..\packages\Rx-Interfaces.2.1.30214.0\lib\Net45\System.Reactive.Interfaces.dll + + + False + ..\packages\Rx-Linq.2.1.30214.0\lib\Net45\System.Reactive.Linq.dll + + + + + + + + + + + + + + + + + + + + + + {3c9f40da-d2a5-43a1-a272-e965876c6d46} + Perspex + + + + + + + + + + False + + + False + + + False + + + False + + + + + + + + \ No newline at end of file diff --git a/Perspex.UnitTests/PerspexObjectTests.cs b/Perspex.UnitTests/PerspexObjectTests.cs new file mode 100644 index 000000000..e6ddeec82 --- /dev/null +++ b/Perspex.UnitTests/PerspexObjectTests.cs @@ -0,0 +1,313 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.UnitTests +{ + using System; + using System.Linq; + using System.Reactive.Linq; + using Microsoft.VisualStudio.TestTools.UnitTesting; + + [TestClass] + public class PerspexObjectTests + { + [TestInitialize] + public void Initialize() + { + // Ensure properties are registered. + PerspexProperty p; + p = Class1.FooProperty; + p = Class2.BarProperty; + } + + [TestMethod] + public void GetProperties_Returns_Registered_Properties() + { + string[] names = PerspexObject.GetProperties(typeof(Class1)).Select(x => x.Name).ToArray(); + + CollectionAssert.AreEqual(new[] { "Foo", "Baz" }, names); + } + + [TestMethod] + public void GetProperties_Returns_Registered_Properties_For_Base_Types() + { + string[] names = PerspexObject.GetProperties(typeof(Class2)).Select(x => x.Name).ToArray(); + + CollectionAssert.AreEqual(new[] { "Bar", "Foo", "Baz" }, names); + } + + [TestMethod] + public void GetValue_Returns_Default_Value() + { + Class1 target = new Class1(); + + Assert.AreEqual("foodefault", target.GetValue(Class1.FooProperty)); + } + + [TestMethod] + public void GetValue_Returns_Overridden_Default_Value() + { + Class2 target = new Class2(); + + Assert.AreEqual("foooverride", target.GetValue(Class1.FooProperty)); + } + + [TestMethod] + public void GetValue_Returns_Set_Value() + { + Class1 target = new Class1(); + + target.SetValue(Class1.FooProperty, "newvalue"); + + Assert.AreEqual("newvalue", target.GetValue(Class1.FooProperty)); + } + + [TestMethod] + public void GetValue_Returns_Inherited_Value() + { + Class1 parent = new Class1(); + Class2 child = new Class2 { Parent = parent }; + + parent.SetValue(Class1.BazProperty, "changed"); + + Assert.AreEqual("changed", child.GetValue(Class1.BazProperty)); + } + + [TestMethod] + public void ClearValue_Clears_Value() + { + Class1 target = new Class1(); + + target.SetValue(Class1.FooProperty, "newvalue"); + target.ClearValue(Class1.FooProperty); + + Assert.AreEqual("foodefault", target.GetValue(Class1.FooProperty)); + } + + [TestMethod] + public void SetValue_Raises_PropertyChanged() + { + Class1 target = new Class1(); + bool raised = false; + + target.PropertyChanged += (s, e) => + { + raised = s == target && + e.Property == Class1.FooProperty && + (string)e.OldValue == "foodefault" && + (string)e.NewValue == "newvalue"; + }; + + target.SetValue(Class1.FooProperty, "newvalue"); + + Assert.IsTrue(raised); + } + + [TestMethod] + public void SetValue_Doesnt_Raise_PropertyChanged_If_Value_Not_Changed() + { + Class1 target = new Class1(); + bool raised = false; + + target.PropertyChanged += (s, e) => + { + raised = true; + }; + + target.SetValue(Class1.FooProperty, "foodefault"); + + Assert.IsFalse(raised); + } + + [TestMethod] + public void GetObservable_Returns_Initial_Value() + { + Class1 target = new Class1(); + bool raised = false; + + target.GetObservable(Class1.FooProperty).Subscribe(x => raised = x == "foodefault"); + + Assert.IsTrue(raised); + } + + [TestMethod] + public void GetObservable_Returns_Property_Change() + { + Class1 target = new Class1(); + bool raised = false; + + target.GetObservable(Class1.FooProperty).Subscribe(x => raised = x == "newvalue"); + raised = false; + target.SetValue(Class1.FooProperty, "newvalue"); + + Assert.IsTrue(raised); + } + + [TestMethod] + public void GetObservable_Returns_Property_Change_Only_For_Correct_Property() + { + Class2 target = new Class2(); + bool raised = false; + + target.GetObservable(Class1.FooProperty).Subscribe(x => raised = true); + raised = false; + target.SetValue(Class2.BarProperty, "newvalue"); + + Assert.IsFalse(raised); + } + + [TestMethod] + public void GetObservable_Dispose_Stops_Property_Changes() + { + Class1 target = new Class1(); + bool raised = false; + + target.GetObservable(Class1.FooProperty) + .Subscribe(x => raised = true) + .Dispose(); + raised = false; + target.SetValue(Class1.FooProperty, "newvalue"); + + Assert.IsFalse(raised); + } + + [TestMethod] + public void Setting_InheritanceParent_Raises_PropertyChanged_When_Value_Changed_In_Parent() + { + bool raised = false; + + Class1 parent = new Class1(); + parent.SetValue(Class1.BazProperty, "changed"); + + Class2 child = new Class2(); + child.PropertyChanged += (s, e) => + raised = s == child && + e.Property == Class1.BazProperty && + (string)e.OldValue == "bazdefault" && + (string)e.NewValue == "changed"; + + child.Parent = parent; + + Assert.IsTrue(raised); + } + + [TestMethod] + public void Setting_InheritanceParent_Doesnt_Raise_PropertyChanged_When_Local_Value_Set() + { + bool raised = false; + + Class1 parent = new Class1(); + parent.SetValue(Class1.BazProperty, "changed"); + + Class2 child = new Class2(); + child.SetValue(Class1.BazProperty, "localvalue"); + child.PropertyChanged += (s, e) => raised = true; + + child.Parent = parent; + + Assert.IsFalse(raised); + } + + [TestMethod] + public void Setting_Value_In_InheritanceParent_Raises_PropertyChanged() + { + bool raised = false; + + Class1 parent = new Class1(); + + Class2 child = new Class2(); + child.PropertyChanged += (s, e) => + raised = s == child && + e.Property == Class1.BazProperty && + (string)e.OldValue == "bazdefault" && + (string)e.NewValue == "changed"; + child.Parent = parent; + + parent.SetValue(Class1.BazProperty, "changed"); + + Assert.IsTrue(raised); + } + + [TestMethod] + public void Bind_Sets_Current_Value() + { + Class1 target = new Class1(); + Class1 source = new Class1(); + + source.SetValue(Class1.FooProperty, "initial"); + target.Bind(Class1.FooProperty, source.GetObservable(Class1.FooProperty)); + + Assert.AreEqual("initial", target.GetValue(Class1.FooProperty)); + } + + [TestMethod] + public void Bind_Sets_Subsequent_Value() + { + Class1 target = new Class1(); + Class1 source = new Class1(); + + source.SetValue(Class1.FooProperty, "initial"); + target.Bind(Class1.FooProperty, source.GetObservable(Class1.FooProperty)); + source.SetValue(Class1.FooProperty, "subsequent"); + + Assert.AreEqual("subsequent", target.GetValue(Class1.FooProperty)); + } + + [TestMethod] + public void Bind_Doesnt_Set_Value_After_Clear() + { + Class1 target = new Class1(); + Class1 source = new Class1(); + + source.SetValue(Class1.FooProperty, "initial"); + target.Bind(Class1.FooProperty, source.GetObservable(Class1.FooProperty)); + target.ClearValue(Class1.FooProperty); + source.SetValue(Class1.FooProperty, "newvalue"); + + Assert.AreEqual("foodefault", target.GetValue(Class1.FooProperty)); + } + + [TestMethod] + public void Bind_Doesnt_Set_Value_After_Reset() + { + Class1 target = new Class1(); + Class1 source = new Class1(); + + source.SetValue(Class1.FooProperty, "initial"); + target.Bind(Class1.FooProperty, source.GetObservable(Class1.FooProperty)); + target.SetValue(Class1.FooProperty, "reset"); + source.SetValue(Class1.FooProperty, "newvalue"); + + Assert.AreEqual("reset", target.GetValue(Class1.FooProperty)); + } + + private class Class1 : PerspexObject + { + public static readonly PerspexProperty FooProperty = + PerspexProperty.Register("Foo", "foodefault"); + + public static readonly PerspexProperty BazProperty = + PerspexProperty.Register("Baz", "bazdefault", true); + } + + private class Class2 : Class1 + { + public static readonly PerspexProperty BarProperty = + PerspexProperty.Register("Bar", "bardefault"); + + static Class2() + { + FooProperty.OverrideDefaultValue(typeof(Class2), "foooverride"); + } + + public Class1 Parent + { + get { return (Class1)this.InheritanceParent; } + set { this.InheritanceParent = value; } + } + } + } +} diff --git a/Perspex.UnitTests/PerspexPropertyTests.cs b/Perspex.UnitTests/PerspexPropertyTests.cs new file mode 100644 index 000000000..3e1a24e6f --- /dev/null +++ b/Perspex.UnitTests/PerspexPropertyTests.cs @@ -0,0 +1,92 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.UnitTests +{ + using System; + using Microsoft.VisualStudio.TestTools.UnitTesting; + + [TestClass] + public class PerspexPropertyTests + { + [TestMethod] + public void Constructor_Sets_Properties() + { + PerspexProperty target = new PerspexProperty( + "test", + typeof(Class1), + "Foo", + false); + + Assert.AreEqual("test", target.Name); + Assert.AreEqual(typeof(string), target.ValueType); + Assert.AreEqual(typeof(Class1), target.OwnerType); + Assert.AreEqual(false, target.Inherits); + } + + [TestMethod] + public void GetDefaultValue_Returns_Registered_Value() + { + PerspexProperty target = new PerspexProperty( + "test", + typeof(Class1), + "Foo", + false); + + Assert.AreEqual("Foo", target.GetDefaultValue()); + } + + [TestMethod] + public void GetDefaultValue_Returns_Registered_Value_For_Not_Overridden_Class() + { + PerspexProperty target = new PerspexProperty( + "test", + typeof(Class1), + "Foo", + false); + + Assert.AreEqual("Foo", target.GetDefaultValue()); + } + + [TestMethod] + public void GetDefaultValue_Returns_Registered_Value_For_Unrelated_Class() + { + PerspexProperty target = new PerspexProperty( + "test", + typeof(Class3), + "Foo", + false); + + Assert.AreEqual("Foo", target.GetDefaultValue()); + } + + [TestMethod] + public void GetDefaultValue_Returns_Overridden_Value() + { + PerspexProperty target = new PerspexProperty( + "test", + typeof(Class1), + "Foo", + false); + + target.OverrideDefaultValue(typeof(Class2), "Bar"); + + Assert.AreEqual("Bar", target.GetDefaultValue()); + } + + private class Class1 : PerspexObject + { + } + + private class Class2 : Class1 + { + } + + private class Class3 + { + } + } +} diff --git a/Perspex.UnitTests/Properties/AssemblyInfo.cs b/Perspex.UnitTests/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..81a5f6d1c --- /dev/null +++ b/Perspex.UnitTests/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Perspex.UnitTests")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Perspex.UnitTests")] +[assembly: AssemblyCopyright("Copyright © 2013")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("fd38c609-0149-487b-b095-3341c409e478")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Perspex.UnitTests/packages.config b/Perspex.UnitTests/packages.config new file mode 100644 index 000000000..09f179893 --- /dev/null +++ b/Perspex.UnitTests/packages.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Perspex.Windows/DrawingContext.cs b/Perspex.Windows/DrawingContext.cs new file mode 100644 index 000000000..8871a965e --- /dev/null +++ b/Perspex.Windows/DrawingContext.cs @@ -0,0 +1,156 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.Windows +{ + using System; + using Perspex.Media; + using Perspex.Windows.Media; + using SharpDX; + using SharpDX.Direct2D1; + + /// + /// Draws using Direct2D1. + /// + public class DrawingContext : IDrawingContext, IDisposable + { + /// + /// The Direct2D1 render target. + /// + private RenderTarget renderTarget; + + /// + /// The DirectWrite factory. + /// + private SharpDX.DirectWrite.Factory directWriteFactory; + + /// + /// Initializes a new instance of the class. + /// + /// The render target to draw to. + /// The DirectWrite factory. + public DrawingContext( + RenderTarget renderTarget, + SharpDX.DirectWrite.Factory directWriteFactory) + { + this.renderTarget = renderTarget; + this.directWriteFactory = directWriteFactory; + this.renderTarget.BeginDraw(); + } + + /// + /// Ends a draw operation. + /// + public void Dispose() + { + this.renderTarget.EndDraw(); + } + + /// + /// Draws the outline of a rectangle. + /// + /// The pen. + /// The rectangle bounds. + public void DrawRectange(Pen pen, Rect rect) + { + using (SharpDX.Direct2D1.SolidColorBrush brush = this.Convert(pen.Brush)) + { + this.renderTarget.DrawRectangle( + this.Convert(rect), + brush, + (float)pen.Thickness); + } + } + + /// + /// Draws text. + /// + /// The foreground brush. + /// The text. + public void DrawText(Perspex.Media.Brush foreground, Rect rect, FormattedText text) + { + using (SharpDX.Direct2D1.SolidColorBrush brush = this.Convert(foreground)) + using (SharpDX.DirectWrite.TextFormat format = TextService.Convert(this.directWriteFactory, text)) + { + this.renderTarget.DrawText( + text.Text, + format, + this.Convert(rect), + brush); + } + } + + /// + /// Draws a filled rectangle. + /// + /// The brush. + /// The rectangle bounds. + public void FillRectange(Perspex.Media.Brush brush, Rect rect) + { + using (SharpDX.Direct2D1.SolidColorBrush b = this.Convert(brush)) + { + this.renderTarget.FillRectangle( + new RectangleF( + (float)rect.X, + (float)rect.Y, + (float)rect.Width, + (float)rect.Height), + b); + } + } + + /// + /// Converts a brush to Direct2D. + /// + /// The brush to convert. + /// The Direct2D brush. + private SharpDX.Direct2D1.SolidColorBrush Convert(Perspex.Media.Brush brush) + { + Perspex.Media.SolidColorBrush solidColorBrush = brush as Perspex.Media.SolidColorBrush; + + if (solidColorBrush != null) + { + return new SharpDX.Direct2D1.SolidColorBrush( + this.renderTarget, + this.Convert(solidColorBrush.Color)); + } + else + { + return new SharpDX.Direct2D1.SolidColorBrush( + this.renderTarget, + new Color4()); + } + } + + /// + /// Converts a color to Direct2D. + /// + /// The color to convert. + /// The Direct2D color. + private Color4 Convert(Perspex.Media.Color color) + { + return new Color4( + (float)(color.R / 255.0), + (float)(color.G / 255.0), + (float)(color.B / 255.0), + (float)(color.A / 255.0)); + } + + /// + /// Converts a to a + /// + /// The . + /// The . + private RectangleF Convert(Rect rect) + { + return new RectangleF( + (float)rect.X, + (float)rect.Y, + (float)rect.Width, + (float)rect.Height); + } + } +} diff --git a/Perspex.Windows/Interop/UnmanagedMethods.cs b/Perspex.Windows/Interop/UnmanagedMethods.cs new file mode 100644 index 000000000..bd59f9a57 --- /dev/null +++ b/Perspex.Windows/Interop/UnmanagedMethods.cs @@ -0,0 +1,488 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.Windows.Interop +{ + using System; + using System.Diagnostics.CodeAnalysis; + using System.Runtime.InteropServices; + using System.Text; + + [SuppressMessage("Microsoft.StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Justification = "Using Win32 naming for consistency.")] + [SuppressMessage("Microsoft.StyleCop.CSharp.NamingRules", "SA1307:AccessibleFieldsMustBeginWithUpperCaseLetter", Justification = "Using Win32 naming for consistency.")] + [SuppressMessage("Microsoft.StyleCop.CSharp.NamingRules", "SA1310:FieldNamesMustNotContainUnderscore", Justification = "Using Win32 naming for consistency.")] + internal static class UnmanagedMethods + { + public const int CW_USEDEFAULT = unchecked((int)0x80000000); + + public delegate void TimerProc(IntPtr hWnd, uint uMsg, IntPtr nIDEvent, uint dwTime); + + public delegate IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam); + + public enum Cursor + { + IDC_ARROW = 32512, + IDC_IBEAM = 32513, + IDC_WAIT = 32514, + IDC_CROSS = 32515, + IDC_UPARROW = 32516, + IDC_SIZE = 32640, + IDC_ICON = 32641, + IDC_SIZENWSE = 32642, + IDC_SIZENESW = 32643, + IDC_SIZEWE = 32644, + IDC_SIZENS = 32645, + IDC_SIZEALL = 32646, + IDC_NO = 32648, + IDC_HAND = 32649, + IDC_APPSTARTING = 32650, + IDC_HELP = 32651 + } + + [Flags] + public enum SetWindowPosFlags : uint + { + SWP_ASYNCWINDOWPOS = 0x4000, + SWP_DEFERERASE = 0x2000, + SWP_DRAWFRAME = 0x0020, + SWP_FRAMECHANGED = 0x0020, + SWP_HIDEWINDOW = 0x0080, + SWP_NOACTIVATE = 0x0010, + SWP_NOCOPYBITS = 0x0100, + SWP_NOMOVE = 0x0002, + SWP_NOOWNERZORDER = 0x0200, + SWP_NOREDRAW = 0x0008, + SWP_NOREPOSITION = 0x0200, + SWP_NOSENDCHANGING = 0x0400, + SWP_NOSIZE = 0x0001, + SWP_NOZORDER = 0x0004, + SWP_SHOWWINDOW = 0x0040, + + SWP_RESIZE = SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOZORDER + } + + [Flags] + public enum WindowStyles : uint + { + WS_BORDER = 0x800000, + WS_CAPTION = 0xc00000, + WS_CHILD = 0x40000000, + WS_CLIPCHILDREN = 0x2000000, + WS_CLIPSIBLINGS = 0x4000000, + WS_DISABLED = 0x8000000, + WS_DLGFRAME = 0x400000, + WS_GROUP = 0x20000, + WS_HSCROLL = 0x100000, + WS_MAXIMIZE = 0x1000000, + WS_MAXIMIZEBOX = 0x10000, + WS_MINIMIZE = 0x20000000, + WS_MINIMIZEBOX = 0x20000, + WS_OVERLAPPED = 0x0, + WS_OVERLAPPEDWINDOW = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_SIZEFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX, + WS_POPUP = 0x80000000u, + WS_POPUPWINDOW = WS_POPUP | WS_BORDER | WS_SYSMENU, + WS_SIZEFRAME = 0x40000, + WS_SYSMENU = 0x80000, + WS_TABSTOP = 0x10000, + WS_VISIBLE = 0x10000000, + WS_VSCROLL = 0x200000, + + WS_EX_DLGMODALFRAME = 0x00000001, + WS_EX_NOPARENTNOTIFY = 0x00000004, + WS_EX_TOPMOST = 0x00000008, + WS_EX_ACCEPTFILES = 0x00000010, + WS_EX_TRANSPARENT = 0x00000020, + WS_EX_MDICHILD = 0x00000040, + WS_EX_TOOLWINDOW = 0x00000080, + WS_EX_WINDOWEDGE = 0x00000100, + WS_EX_CLIENTEDGE = 0x00000200, + WS_EX_CONTEXTHELP = 0x00000400, + WS_EX_RIGHT = 0x00001000, + WS_EX_LEFT = 0x00000000, + WS_EX_RTLREADING = 0x00002000, + WS_EX_LTRREADING = 0x00000000, + WS_EX_LEFTSCROLLBAR = 0x00004000, + WS_EX_RIGHTSCROLLBAR = 0x00000000, + WS_EX_CONTROLPARENT = 0x00010000, + WS_EX_STATICEDGE = 0x00020000, + WS_EX_APPWINDOW = 0x00040000, + WS_EX_OVERLAPPEDWINDOW = (WS_EX_WINDOWEDGE | WS_EX_CLIENTEDGE), + WS_EX_PALETTEWINDOW = (WS_EX_WINDOWEDGE | WS_EX_TOOLWINDOW | WS_EX_TOPMOST), + WS_EX_LAYERED = 0x00080000, + WS_EX_NOINHERITLAYOUT = 0x00100000, + WS_EX_LAYOUTRTL = 0x00400000, + WS_EX_COMPOSITED = 0x02000000, + WS_EX_NOACTIVATE = 0x08000000 + } + + public enum WindowsMessage : uint + { + WM_NULL = 0x0000, + WM_CREATE = 0x0001, + WM_DESTROY = 0x0002, + WM_MOVE = 0x0003, + WM_SIZE = 0x0005, + WM_ACTIVATE = 0x0006, + WM_SETFOCUS = 0x0007, + WM_KILLFOCUS = 0x0008, + WM_ENABLE = 0x000A, + WM_SETREDRAW = 0x000B, + WM_SETTEXT = 0x000C, + WM_GETTEXT = 0x000D, + WM_GETTEXTLENGTH = 0x000E, + WM_PAINT = 0x000F, + WM_CLOSE = 0x0010, + WM_QUERYENDSESSION = 0x0011, + WM_QUERYOPEN = 0x0013, + WM_ENDSESSION = 0x0016, + WM_QUIT = 0x0012, + WM_ERASEBKGND = 0x0014, + WM_SYSCOLORCHANGE = 0x0015, + WM_SHOWWINDOW = 0x0018, + WM_WININICHANGE = 0x001A, + WM_SETTINGCHANGE = WM_WININICHANGE, + WM_DEVMODECHANGE = 0x001B, + WM_ACTIVATEAPP = 0x001C, + WM_FONTCHANGE = 0x001D, + WM_TIMECHANGE = 0x001E, + WM_CANCELMODE = 0x001F, + WM_SETCURSOR = 0x0020, + WM_MOUSEACTIVATE = 0x0021, + WM_CHILDACTIVATE = 0x0022, + WM_QUEUESYNC = 0x0023, + WM_GETMINMAXINFO = 0x0024, + WM_PAINTICON = 0x0026, + WM_ICONERASEBKGND = 0x0027, + WM_NEXTDLGCTL = 0x0028, + WM_SPOOLERSTATUS = 0x002A, + WM_DRAWITEM = 0x002B, + WM_MEASUREITEM = 0x002C, + WM_DELETEITEM = 0x002D, + WM_VKEYTOITEM = 0x002E, + WM_CHARTOITEM = 0x002F, + WM_SETFONT = 0x0030, + WM_GETFONT = 0x0031, + WM_SETHOTKEY = 0x0032, + WM_GETHOTKEY = 0x0033, + WM_QUERYDRAGICON = 0x0037, + WM_COMPAREITEM = 0x0039, + WM_GETOBJECT = 0x003D, + WM_COMPACTING = 0x0041, + WM_WINDOWPOSCHANGING = 0x0046, + WM_WINDOWPOSCHANGED = 0x0047, + WM_COPYDATA = 0x004A, + WM_CANCELJOURNAL = 0x004B, + WM_NOTIFY = 0x004E, + WM_INPUTLANGCHANGEREQUEST = 0x0050, + WM_INPUTLANGCHANGE = 0x0051, + WM_TCARD = 0x0052, + WM_HELP = 0x0053, + WM_USERCHANGED = 0x0054, + WM_NOTIFYFORMAT = 0x0055, + WM_CONTEXTMENU = 0x007B, + WM_STYLECHANGING = 0x007C, + WM_STYLECHANGED = 0x007D, + WM_DISPLAYCHANGE = 0x007E, + WM_GETICON = 0x007F, + WM_SETICON = 0x0080, + WM_NCCREATE = 0x0081, + WM_NCDESTROY = 0x0082, + WM_NCCALCSIZE = 0x0083, + WM_NCHITTEST = 0x0084, + WM_NCPAINT = 0x0085, + WM_NCACTIVATE = 0x0086, + WM_GETDLGCODE = 0x0087, + WM_SYNCPAINT = 0x0088, + WM_NCMOUSEMOVE = 0x00A0, + WM_NCLBUTTONDOWN = 0x00A1, + WM_NCLBUTTONUP = 0x00A2, + WM_NCLBUTTONDBLCLK = 0x00A3, + WM_NCRBUTTONDOWN = 0x00A4, + WM_NCRBUTTONUP = 0x00A5, + WM_NCRBUTTONDBLCLK = 0x00A6, + WM_NCMBUTTONDOWN = 0x00A7, + WM_NCMBUTTONUP = 0x00A8, + WM_NCMBUTTONDBLCLK = 0x00A9, + WM_NCXBUTTONDOWN = 0x00AB, + WM_NCXBUTTONUP = 0x00AC, + WM_NCXBUTTONDBLCLK = 0x00AD, + WM_INPUT_DEVICE_CHANGE = 0x00FE, + WM_INPUT = 0x00FF, + WM_KEYFIRST = 0x0100, + WM_KEYDOWN = 0x0100, + WM_KEYUP = 0x0101, + WM_CHAR = 0x0102, + WM_DEADCHAR = 0x0103, + WM_SYSKEYDOWN = 0x0104, + WM_SYSKEYUP = 0x0105, + WM_SYSCHAR = 0x0106, + WM_SYSDEADCHAR = 0x0107, + WM_UNICHAR = 0x0109, + WM_KEYLAST = 0x0109, + WM_IME_STARTCOMPOSITION = 0x010D, + WM_IME_ENDCOMPOSITION = 0x010E, + WM_IME_COMPOSITION = 0x010F, + WM_IME_KEYLAST = 0x010F, + WM_INITDIALOG = 0x0110, + WM_COMMAND = 0x0111, + WM_SYSCOMMAND = 0x0112, + WM_TIMER = 0x0113, + WM_HSCROLL = 0x0114, + WM_VSCROLL = 0x0115, + WM_INITMENU = 0x0116, + WM_INITMENUPOPUP = 0x0117, + WM_MENUSELECT = 0x011F, + WM_MENUCHAR = 0x0120, + WM_ENTERIDLE = 0x0121, + WM_MENURBUTTONUP = 0x0122, + WM_MENUDRAG = 0x0123, + WM_MENUGETOBJECT = 0x0124, + WM_UNINITMENUPOPUP = 0x0125, + WM_MENUCOMMAND = 0x0126, + WM_CHANGEUISTATE = 0x0127, + WM_UPDATEUISTATE = 0x0128, + WM_QUERYUISTATE = 0x0129, + WM_CTLCOLORMSGBOX = 0x0132, + WM_CTLCOLOREDIT = 0x0133, + WM_CTLCOLORLISTBOX = 0x0134, + WM_CTLCOLORBTN = 0x0135, + WM_CTLCOLORDLG = 0x0136, + WM_CTLCOLORSCROLLBAR = 0x0137, + WM_CTLCOLORSTATIC = 0x0138, + WM_MOUSEFIRST = 0x0200, + WM_MOUSEMOVE = 0x0200, + WM_LBUTTONDOWN = 0x0201, + WM_LBUTTONUP = 0x0202, + WM_LBUTTONDBLCLK = 0x0203, + WM_RBUTTONDOWN = 0x0204, + WM_RBUTTONUP = 0x0205, + WM_RBUTTONDBLCLK = 0x0206, + WM_MBUTTONDOWN = 0x0207, + WM_MBUTTONUP = 0x0208, + WM_MBUTTONDBLCLK = 0x0209, + WM_MOUSEWHEEL = 0x020A, + WM_XBUTTONDOWN = 0x020B, + WM_XBUTTONUP = 0x020C, + WM_XBUTTONDBLCLK = 0x020D, + WM_MOUSEHWHEEL = 0x020E, + WM_MOUSELAST = 0x020E, + WM_PARENTNOTIFY = 0x0210, + WM_ENTERMENULOOP = 0x0211, + WM_EXITMENULOOP = 0x0212, + WM_NEXTMENU = 0x0213, + WM_SIZING = 0x0214, + WM_CAPTURECHANGED = 0x0215, + WM_MOVING = 0x0216, + WM_POWERBROADCAST = 0x0218, + WM_DEVICECHANGE = 0x0219, + WM_MDICREATE = 0x0220, + WM_MDIDESTROY = 0x0221, + WM_MDIACTIVATE = 0x0222, + WM_MDIRESTORE = 0x0223, + WM_MDINEXT = 0x0224, + WM_MDIMAXIMIZE = 0x0225, + WM_MDITILE = 0x0226, + WM_MDICASCADE = 0x0227, + WM_MDIICONARRANGE = 0x0228, + WM_MDIGETACTIVE = 0x0229, + WM_MDISETMENU = 0x0230, + WM_ENTERSIZEMOVE = 0x0231, + WM_EXITSIZEMOVE = 0x0232, + WM_DROPFILES = 0x0233, + WM_MDIREFRESHMENU = 0x0234, + WM_IME_SETCONTEXT = 0x0281, + WM_IME_NOTIFY = 0x0282, + WM_IME_CONTROL = 0x0283, + WM_IME_COMPOSITIONFULL = 0x0284, + WM_IME_SELECT = 0x0285, + WM_IME_CHAR = 0x0286, + WM_IME_REQUEST = 0x0288, + WM_IME_KEYDOWN = 0x0290, + WM_IME_KEYUP = 0x0291, + WM_MOUSEHOVER = 0x02A1, + WM_MOUSELEAVE = 0x02A3, + WM_NCMOUSEHOVER = 0x02A0, + WM_NCMOUSELEAVE = 0x02A2, + WM_WTSSESSION_CHANGE = 0x02B1, + WM_TABLET_FIRST = 0x02c0, + WM_TABLET_LAST = 0x02df, + WM_CUT = 0x0300, + WM_COPY = 0x0301, + WM_PASTE = 0x0302, + WM_CLEAR = 0x0303, + WM_UNDO = 0x0304, + WM_RENDERFORMAT = 0x0305, + WM_RENDERALLFORMATS = 0x0306, + WM_DESTROYCLIPBOARD = 0x0307, + WM_DRAWCLIPBOARD = 0x0308, + WM_PAINTCLIPBOARD = 0x0309, + WM_VSCROLLCLIPBOARD = 0x030A, + WM_SIZECLIPBOARD = 0x030B, + WM_ASKCBFORMATNAME = 0x030C, + WM_CHANGECBCHAIN = 0x030D, + WM_HSCROLLCLIPBOARD = 0x030E, + WM_QUERYNEWPALETTE = 0x030F, + WM_PALETTEISCHANGING = 0x0310, + WM_PALETTECHANGED = 0x0311, + WM_HOTKEY = 0x0312, + WM_PRINT = 0x0317, + WM_PRINTCLIENT = 0x0318, + WM_APPCOMMAND = 0x0319, + WM_THEMECHANGED = 0x031A, + WM_CLIPBOARDUPDATE = 0x031D, + WM_DWMCOMPOSITIONCHANGED = 0x031E, + WM_DWMNCRENDERINGCHANGED = 0x031F, + WM_DWMCOLORIZATIONCOLORCHANGED = 0x0320, + WM_DWMWINDOWMAXIMIZEDCHANGE = 0x0321, + WM_GETTITLEBARINFOEX = 0x033F, + WM_HANDHELDFIRST = 0x0358, + WM_HANDHELDLAST = 0x035F, + WM_AFXFIRST = 0x0360, + WM_AFXLAST = 0x037F, + WM_PENWINFIRST = 0x0380, + WM_PENWINLAST = 0x038F, + WM_APP = 0x8000, + WM_USER = 0x0400, + + WM_DISPATCH_WORK_ITEM = WM_USER, + } + + [DllImport("user32.dll")] + public static extern bool ClientToScreen(IntPtr hWnd, ref POINT lpPoint); + + [DllImport("user32.dll")] + public static extern IntPtr DefWindowProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam); + + [DllImport("user32.dll")] + public static extern IntPtr DispatchMessage(ref MSG lpmsg); + + [DllImport("user32.dll", SetLastError = true)] + public static extern bool DestroyWindow(IntPtr hwnd); + + [DllImport("user32.dll")] + public static extern uint GetCaretBlinkTime(); + + [DllImport("user32.dll")] + public static extern bool GetClientRect(IntPtr hwnd, out RECT lpRect); + + [DllImport("user32.dll")] + public static extern bool GetCursorPos(out POINT lpPoint); + + [DllImport("user32.dll")] + public static extern bool GetKeyboardState(byte[] lpKeyState); + + [DllImport("user32.dll")] + public static extern sbyte GetMessage(out MSG lpMsg, IntPtr hWnd, uint wMsgFilterMin, uint wMsgFilterMax); + + [DllImport("kernel32.dll")] + public static extern IntPtr GetModuleHandle(string lpModuleName); + + [DllImport("user32.dll")] + public static extern bool GetWindowRect(IntPtr hwnd, out RECT lpRect); + + [DllImport("user32.dll")] + public static extern bool KillTimer(IntPtr hWnd, IntPtr uIDEvent); + + [DllImport("user32.dll")] + public static extern IntPtr LoadCursor(IntPtr hInstance, int lpCursorName); + + [DllImport("user32.dll")] + public static extern IntPtr PostMessage(IntPtr hWnd, int msg, IntPtr wParam, IntPtr lParam); + + [DllImport("user32.dll", SetLastError = true)] + public static extern ushort RegisterClassEx(ref WNDCLASSEX lpwcx); + + [DllImport("user32.dll")] + public static extern bool ReleaseCapture(); + + [DllImport("user32.dll")] + public static extern bool ScreenToClient(IntPtr hWnd, ref POINT lpPoint); + + [DllImport("user32.dll")] + public static extern IntPtr SetCapture(IntPtr hWnd); + + [DllImport("user32.dll")] + public static extern IntPtr SetTimer(IntPtr hWnd, IntPtr nIDEvent, uint uElapse, TimerProc lpTimerFunc); + + [DllImport("user32.dll")] + public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int x, int y, int cx, int cy, SetWindowPosFlags uFlags); + + [DllImport("user32.dll")] + public static extern bool ShowWindow(IntPtr hWnd, uint nCmdShow); + + [DllImport("user32.dll")] + public static extern int ToUnicode( + uint virtualKeyCode, + uint scanCode, + byte[] keyboardState, + [Out, MarshalAs(UnmanagedType.LPWStr, SizeConst = 64)] + StringBuilder receivingBuffer, + int bufferSize, + uint flags); + + [DllImport("user32.dll")] + public static extern bool TranslateMessage(ref MSG lpMsg); + + [DllImport("user32.dll")] + public static extern bool UnregisterClass(string lpClassName, IntPtr hInstance); + + [DllImport("user32.dll", SetLastError = true)] + public static extern IntPtr CreateWindowEx( + int dwExStyle, + uint lpClassName, + string lpWindowName, + int dwStyle, + int x, + int y, + int nWidth, + int nHeight, + IntPtr hWndParent, + IntPtr hMenu, + IntPtr hInstance, + IntPtr lpParam); + + public struct MSG + { + public IntPtr hwnd; + public uint message; + public IntPtr wParam; + public IntPtr lParam; + public uint time; + public POINT pt; + } + + public struct POINT + { + public int X; + public int Y; + } + + public struct RECT + { + public int left; + public int top; + public int right; + public int bottom; + } + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + public struct WNDCLASSEX + { + public int cbSize; + public int style; + public WndProc lpfnWndProc; + public int cbClsExtra; + public int cbWndExtra; + public IntPtr hInstance; + public IntPtr hIcon; + public IntPtr hCursor; + public IntPtr hbrBackground; + public string lpszMenuName; + public string lpszClassName; + public IntPtr hIconSm; + } + } +} diff --git a/Perspex.Windows/Media/TextService.cs b/Perspex.Windows/Media/TextService.cs new file mode 100644 index 000000000..79d7190f0 --- /dev/null +++ b/Perspex.Windows/Media/TextService.cs @@ -0,0 +1,32 @@ +namespace Perspex.Windows.Media +{ + using Perspex.Media; + using SharpDX.DirectWrite; + + public class TextService : ITextService + { + private Factory factory; + + public TextService(Factory factory) + { + this.factory = factory; + } + + public static TextFormat Convert(Factory factory, FormattedText text) + { + return new TextFormat( + factory, + text.FontFamilyName, + (float)text.FontSize); + } + + public Size Measure(FormattedText text) + { + TextFormat f = Convert(this.factory, text); + TextLayout layout = new TextLayout(this.factory, text.Text, f, float.MaxValue, float.MaxValue); + return new Size( + layout.Metrics.WidthIncludingTrailingWhitespace, + layout.Metrics.Height); + } + } +} diff --git a/Perspex.Windows/Perspex.Windows.csproj b/Perspex.Windows/Perspex.Windows.csproj new file mode 100644 index 000000000..104eec82f --- /dev/null +++ b/Perspex.Windows/Perspex.Windows.csproj @@ -0,0 +1,115 @@ + + + + + Debug + AnyCPU + {811A76CF-1CF6-440F-963B-BBE31BD72A82} + Library + Properties + Perspex.Windows + Perspex.Windows + v4.5 + 512 + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + ..\packages\SharpDX.2.5.0\lib\net40\SharpDX.dll + + + ..\packages\SharpDX.Direct2D1.2.5.0\lib\net40\SharpDX.Direct2D1.dll + + + ..\packages\SharpDX.DXGI.2.5.0\lib\net40\SharpDX.DXGI.dll + + + + + + ..\packages\Rx-Core.2.1.30214.0\lib\Net45\System.Reactive.Core.dll + + + ..\packages\Rx-Interfaces.2.1.30214.0\lib\Net45\System.Reactive.Interfaces.dll + + + ..\packages\Rx-Linq.2.1.30214.0\lib\Net45\System.Reactive.Linq.dll + + + ..\packages\Rx-PlatformServices.2.1.30214.0\lib\Net45\System.Reactive.PlatformServices.dll + + + + + + + + + + + + + + + + + + + + + + {3c9f40da-d2a5-43a1-a272-e965876c6d46} + Perspex + + + + + + + + + ..\packages\StyleCop.MSBuild.4.7.46.0\tools\StyleCop.targets + + + + Failed to import StyleCop.MSBuild targets from '$(StyleCopMSBuildTargetsFile)'. The StyleCop.MSBuild package was either missing or incomplete when the project was loaded. Ensure that the package is present and then restart the build. If you are using an IDE (e.g. Visual Studio), reload the project before restarting the build. + Failed to import StyleCop.MSBuild targets from '$(StyleCopMSBuildTargetsFile)'. The StyleCop.MSBuild package was either missing or incomplete when the project was loaded (but is now present). To fix this, restart the build. If you are using an IDE (e.g. Visual Studio), reload the project before restarting the build. + Failed to import StyleCop.MSBuild targets from '$(StyleCopMSBuildTargetsFile)'. The StyleCop.MSBuild package was either missing or incomplete when the project was loaded. To fix this, restore the package and then restart the build. If you are using an IDE (e.g. Visual Studio), you may need to reload the project before restarting the build. Note that regular NuGet package restore (during build) does not work with this package because the package needs to be present before the project is loaded. If this is an automated build (e.g. CI server), you may want to ensure that the build process restores the StyleCop.MSBuild package before the project is built. + Failed to import StyleCop.MSBuild targets from '$(StyleCopMSBuildTargetsFile)'. The StyleCop.MSBuild package was either missing or incomplete when the project was loaded (but is now present). To fix this, restart the build. If you are using an IDE (e.g. Visual Studio), reload the project before restarting the build. Note that when using regular NuGet package restore (during build) the package will not be available for the initial build because the package needs to be present before the project is loaded. If package restore executes successfully in the intitial build then the package will be available for subsequent builds. If this is an automated build (e.g. CI server), you may want to ensure that the build process restores the StyleCop.MSBuild package before the initial build. + + + + + + + + + + + + + StyleCopMSBuildTargetsNotFound;$(PrepareForBuildDependsOn) + + \ No newline at end of file diff --git a/Perspex.Windows/Properties/AssemblyInfo.cs b/Perspex.Windows/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..de730fb1e --- /dev/null +++ b/Perspex.Windows/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Perspex.Windows")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Perspex.Windows")] +[assembly: AssemblyCopyright("Copyright © 2013")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("6bef7635-86fb-490e-8a97-a5134a63ec9b")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Perspex.Windows/Renderer.cs b/Perspex.Windows/Renderer.cs new file mode 100644 index 000000000..94575517c --- /dev/null +++ b/Perspex.Windows/Renderer.cs @@ -0,0 +1,106 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.Windows +{ + using System; + using SharpDX; + using SharpDX.Direct2D1; + using DwFactory = SharpDX.DirectWrite.Factory; + + /// + /// Renders a . + /// + public class Renderer + { + /// + /// The render target. + /// + private WindowRenderTarget renderTarget; + + /// + /// Initializes a new instance of the class. + /// + /// The window handle. + /// The width of the window. + /// The height of the window. + public Renderer(IntPtr hwnd, int width, int height) + { + this.Direct2DFactory = new Factory(); + this.DirectWriteFactory = new DwFactory(); + + RenderTargetProperties renderTargetProperties = new RenderTargetProperties + { + }; + + HwndRenderTargetProperties hwndProperties = new HwndRenderTargetProperties + { + Hwnd = hwnd, + PixelSize = new Size2(width, height), + }; + + this.renderTarget = new WindowRenderTarget( + this.Direct2DFactory, + renderTargetProperties, + hwndProperties); + } + + /// + /// Gets the Direct2D factory. + /// + public Factory Direct2DFactory + { + get; + private set; + } + + /// + /// Gets the DirectWrite factory. + /// + public DwFactory DirectWriteFactory + { + get; + private set; + } + + /// + /// Renders the specified visual. + /// + /// The visual to render. + public void Render(Visual visual) + { + using (DrawingContext context = new DrawingContext(this.renderTarget, this.DirectWriteFactory)) + { + this.Render(visual, context); + } + } + + /// + /// Resizes the renderer. + /// + /// The new width. + /// The new height. + public void Resize(int width, int height) + { + this.renderTarget.Resize(new Size2(width, height)); + } + + /// + /// Renders the specified visual. + /// + /// The visual to render. + /// The drawing context. + private void Render(Visual visual, DrawingContext context) + { + visual.Render(context); + + foreach (Visual child in visual.VisualChildren) + { + this.Render(child, context); + } + } + } +} diff --git a/Perspex.Windows/Threading/Dispatcher.cs b/Perspex.Windows/Threading/Dispatcher.cs new file mode 100644 index 000000000..7ff6e569d --- /dev/null +++ b/Perspex.Windows/Threading/Dispatcher.cs @@ -0,0 +1,637 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.Windows.Threading +{ + using System; + using System.Collections.Generic; + using System.ComponentModel; + using System.Security; + using System.Threading; + using Perspex.Windows.Interop; + + public enum DispatcherPriority + { + Invalid = -1, + Inactive = 0, + SystemIdle = 1, + ApplicationIdle = 2, + ContextIdle = 3, + Background = 4, + Input = 5, + Loaded = 6, + Render = 7, + DataBind = 8, + Normal = 9, + Send = 10, + } + + [Flags] + internal enum Flags + { + ShutdownStarted = 1, + Shutdown = 2, + Disabled = 4 + } + + public sealed class Dispatcher + { + private const int TopPriority = (int)DispatcherPriority.Send; + + private static Dictionary dispatchers = new Dictionary(); + + private static object olock = new object(); + + private static DispatcherFrame mainExecutionFrame = new DispatcherFrame(); + + private Thread baseThread; + + private PokableQueue[] priorityQueues = new PokableQueue[TopPriority + 1]; + + private Flags flags; + + private int queueBits; + + private DispatcherFrame currentFrame; + + private Dispatcher(Thread t) + { + this.baseThread = t; + + for (int i = 1; i <= (int)DispatcherPriority.Send; i++) + { + this.priorityQueues[i] = new PokableQueue(); + } + } + + public event EventHandler ShutdownStarted; + + public event EventHandler ShutdownFinished; + + public static Dispatcher CurrentDispatcher + { + get + { + lock (olock) + { + Thread t = Thread.CurrentThread; + Dispatcher dis = FromThread(t); + + if (dis != null) + { + return dis; + } + + dis = new Dispatcher(t); + dispatchers[t] = dis; + return dis; + } + } + } + + public Thread Thread + { + get + { + return this.baseThread; + } + } + + public bool HasShutdownStarted + { + get + { + return (this.flags & Flags.ShutdownStarted) != 0; + } + } + + public bool HasShutdownFinished + { + get + { + return (this.flags & Flags.Shutdown) != 0; + } + } + + [SecurityCritical] + public static void ExitAllFrames() + { + Dispatcher dis = CurrentDispatcher; + + for (DispatcherFrame frame = dis.currentFrame; frame != null; frame = frame.ParentFrame) + { + if (frame.ExitOnRequest) + { + frame.Continue = false; + } + else + { + break; + } + } + } + + public static Dispatcher FromThread(Thread thread) + { + Dispatcher dis; + + if (dispatchers.TryGetValue(thread, out dis)) + { + return dis; + } + + return null; + } + + [SecurityCritical] + public static void PushFrame(DispatcherFrame frame) + { + if (frame == null) + { + throw new ArgumentNullException("frame"); + } + + Dispatcher dis = CurrentDispatcher; + + if (dis.HasShutdownFinished) + { + throw new InvalidOperationException("The Dispatcher has shut down"); + } + + if (frame.Running != null) + { + throw new InvalidOperationException("Frame is already running on a different dispatcher"); + } + + if ((dis.flags & Flags.Disabled) != 0) + { + throw new InvalidOperationException("Dispatcher processing has been disabled"); + } + + frame.ParentFrame = dis.currentFrame; + dis.currentFrame = frame; + + frame.Running = dis; + + dis.RunFrame(frame); + } + + [SecurityCritical] + public static void Run() + { + PushFrame(mainExecutionFrame); + } + + public static void ValidatePriority(DispatcherPriority priority, string parameterName) + { + if (priority < DispatcherPriority.Inactive || priority > DispatcherPriority.Send) + { + throw new InvalidEnumArgumentException(parameterName); + } + } + + [EditorBrowsable(EditorBrowsableState.Never)] + public bool CheckAccess() + { + return Thread.CurrentThread == this.baseThread; + } + + [EditorBrowsable(EditorBrowsableState.Never)] + public void VerifyAccess() + { + if (Thread.CurrentThread != this.baseThread) + { + throw new InvalidOperationException("Invoked from a different thread"); + } + } + + public DispatcherOperation BeginInvoke(Delegate method, params object[] args) + { + throw new NotImplementedException(); + } + + public DispatcherOperation BeginInvoke(Delegate method, DispatcherPriority priority, params object[] args) + { + throw new NotImplementedException(); + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public DispatcherOperation BeginInvoke(DispatcherPriority priority, Delegate method) + { + if (priority < 0 || priority > DispatcherPriority.Send) + { + throw new InvalidEnumArgumentException("priority"); + } + + if (priority == DispatcherPriority.Inactive) + { + throw new ArgumentException("priority can not be inactive", "priority"); + } + + if (method == null) + { + throw new ArgumentNullException("method"); + } + + DispatcherOperation op = new DispatcherOperation(this, priority, method); + this.Queue(priority, op); + + return op; + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public DispatcherOperation BeginInvoke(DispatcherPriority priority, Delegate method, object arg) + { + if (priority < 0 || priority > DispatcherPriority.Send) + { + throw new InvalidEnumArgumentException("priority"); + } + + if (priority == DispatcherPriority.Inactive) + { + throw new ArgumentException("priority can not be inactive", "priority"); + } + + if (method == null) + { + throw new ArgumentNullException("method"); + } + + DispatcherOperation op = new DispatcherOperation(this, priority, method, arg); + + this.Queue(priority, op); + + return op; + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public DispatcherOperation BeginInvoke(DispatcherPriority priority, Delegate method, object arg, params object[] args) + { + if (priority < 0 || priority > DispatcherPriority.Send) + { + throw new InvalidEnumArgumentException("priority"); + } + + if (priority == DispatcherPriority.Inactive) + { + throw new ArgumentException("priority can not be inactive", "priority"); + } + + if (method == null) + { + throw new ArgumentNullException("method"); + } + + DispatcherOperation op = new DispatcherOperation(this, priority, method, arg, args); + this.Queue(priority, op); + + return op; + } + + public object Invoke(Delegate method, params object[] args) + { + throw new NotImplementedException(); + } + + public object Invoke(Delegate method, TimeSpan timeout, params object[] args) + { + throw new NotImplementedException(); + } + + public object Invoke(Delegate method, TimeSpan timeout, DispatcherPriority priority, params object[] args) + { + throw new NotImplementedException(); + } + + public object Invoke(Delegate method, DispatcherPriority priority, params object[] args) + { + throw new NotImplementedException(); + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public object Invoke(DispatcherPriority priority, Delegate method) + { + if (priority < 0 || priority > DispatcherPriority.Send) + { + throw new InvalidEnumArgumentException("priority"); + } + + if (priority == DispatcherPriority.Inactive) + { + throw new ArgumentException("priority can not be inactive", "priority"); + } + + if (method == null) + { + throw new ArgumentNullException("method"); + } + + DispatcherOperation op = new DispatcherOperation(this, priority, method); + this.Queue(priority, op); + PushFrame(new DispatcherFrame()); + + throw new NotImplementedException(); + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public object Invoke(DispatcherPriority priority, Delegate method, object arg) + { + if (priority < 0 || priority > DispatcherPriority.Send) + { + throw new InvalidEnumArgumentException("priority"); + } + + if (priority == DispatcherPriority.Inactive) + { + throw new ArgumentException("priority can not be inactive", "priority"); + } + + if (method == null) + { + throw new ArgumentNullException("method"); + } + + this.Queue(priority, new DispatcherOperation(this, priority, method, arg)); + throw new NotImplementedException(); + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public object Invoke(DispatcherPriority priority, Delegate method, object arg, params object[] args) + { + if (priority < 0 || priority > DispatcherPriority.Send) + { + throw new InvalidEnumArgumentException("priority"); + } + + if (priority == DispatcherPriority.Inactive) + { + throw new ArgumentException("priority can not be inactive", "priority"); + } + + if (method == null) + { + throw new ArgumentNullException("method"); + } + + this.Queue(priority, new DispatcherOperation(this, priority, method, arg, args)); + + throw new NotImplementedException(); + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public object Invoke(DispatcherPriority priority, TimeSpan timeout, Delegate method) + { + throw new NotImplementedException(); + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public object Invoke(DispatcherPriority priority, TimeSpan timeout, Delegate method, object arg) + { + throw new NotImplementedException(); + } + + [Browsable(false)] + [EditorBrowsable(EditorBrowsableState.Never)] + public object Invoke(DispatcherPriority priority, TimeSpan timeout, Delegate method, object arg, params object[] args) + { + throw new NotImplementedException(); + } + + [SecurityCritical] + public void InvokeShutdown() + { + this.flags |= Flags.ShutdownStarted; + + UnmanagedMethods.PostMessage( + IntPtr.Zero, + (int)UnmanagedMethods.WindowsMessage.WM_DISPATCH_WORK_ITEM, + IntPtr.Zero, + IntPtr.Zero); + } + + [SecurityCritical] + public void BeginInvokeShutdown(DispatcherPriority priority) + { + throw new NotImplementedException(); + } + + internal void Reprioritize(DispatcherOperation op, DispatcherPriority oldpriority) + { + int oldp = (int)oldpriority; + PokableQueue q = this.priorityQueues[oldp]; + + lock (q) + { + q.Remove(op); + } + + this.Queue(op.Priority, op); + } + + private void Queue(DispatcherPriority priority, DispatcherOperation x) + { + int p = (int)priority; + PokableQueue q = this.priorityQueues[p]; + + lock (q) + { + int flag = 1 << p; + q.Enqueue(x); + this.queueBits |= flag; + } + + if (Thread.CurrentThread != this.baseThread) + { + UnmanagedMethods.PostMessage( + IntPtr.Zero, + (int)UnmanagedMethods.WindowsMessage.WM_DISPATCH_WORK_ITEM, + IntPtr.Zero, + IntPtr.Zero); + } + } + + private void PerformShutdown() + { + EventHandler h; + + h = this.ShutdownStarted; + if (h != null) + { + h(this, new EventArgs()); + } + + this.flags |= Flags.Shutdown; + + h = this.ShutdownFinished; + if (h != null) + { + h(this, new EventArgs()); + } + + this.priorityQueues = null; + } + + private void RunFrame(DispatcherFrame frame) + { + do + { + while (this.queueBits != 0) + { + for (int i = TopPriority; i > 0 && this.queueBits != 0; i--) + { + int currentBit = this.queueBits & (1 << i); + if (currentBit != 0) + { + PokableQueue q = this.priorityQueues[i]; + + do + { + DispatcherOperation task; + + lock (q) + { + task = (DispatcherOperation)q.Dequeue(); + } + + task.Invoke(); + + if (!frame.Continue) + { + return; + } + + if (this.HasShutdownStarted) + { + this.PerformShutdown(); + return; + } + + lock (q) + { + if (q.Count == 0) + { + this.queueBits &= ~(1 << i); + break; + } + } + + if (currentBit < (this.queueBits & ~currentBit)) + { + break; + } + } + while (true); + } + } + } + + UnmanagedMethods.MSG msg; + UnmanagedMethods.GetMessage(out msg, IntPtr.Zero, 0, 0); + UnmanagedMethods.TranslateMessage(ref msg); + UnmanagedMethods.DispatchMessage(ref msg); + + if (this.HasShutdownStarted) + { + this.PerformShutdown(); + return; + } + } + while (frame.Continue); + } + + private class PokableQueue + { + private const int InitialCapacity = 32; + + private int size, head, tail; + private object[] array; + + internal PokableQueue(int capacity) + { + this.array = new object[capacity]; + } + + internal PokableQueue() + : this(InitialCapacity) + { + } + + public int Count + { + get + { + return this.size; + } + } + + public void Enqueue(object obj) + { + if (this.size == this.array.Length) + { + this.Grow(); + } + + this.array[this.tail] = obj; + this.tail = (this.tail + 1) % this.array.Length; + this.size++; + } + + public object Dequeue() + { + if (this.size < 1) + { + throw new InvalidOperationException(); + } + + object result = this.array[this.head]; + this.array[this.head] = null; + this.head = (this.head + 1) % this.array.Length; + this.size--; + return result; + } + + public void Remove(object obj) + { + for (int i = 0; i < this.size; i++) + { + if (this.array[(this.head + i) % this.array.Length] == obj) + { + for (int j = i; j < this.size - i; j++) + { + this.array[(this.head + j) % this.array.Length] = this.array[(this.head + j + 1) % this.array.Length]; + } + + this.size--; + if (this.size < 0) + { + this.size = this.array.Length - 1; + } + + this.tail--; + } + } + } + + private void Grow() + { + int newc = this.array.Length * 2; + object[] newContents = new object[newc]; + this.array.CopyTo(newContents, 0); + this.array = newContents; + this.head = 0; + this.tail = this.head + this.size; + } + } + } +} \ No newline at end of file diff --git a/Perspex.Windows/Threading/DispatcherFrame.cs b/Perspex.Windows/Threading/DispatcherFrame.cs new file mode 100644 index 000000000..c2198cf95 --- /dev/null +++ b/Perspex.Windows/Threading/DispatcherFrame.cs @@ -0,0 +1,25 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.Windows.Threading +{ + public class DispatcherFrame + { + public DispatcherFrame() + { + this.Continue = true; + this.ExitOnRequest = true; + } + + public bool Continue { get; set; } + + internal bool ExitOnRequest { get; set; } + + internal Dispatcher Running { get; set; } + + internal DispatcherFrame ParentFrame { get; set; } + } +} diff --git a/Perspex.Windows/Threading/DispatcherOperation.cs b/Perspex.Windows/Threading/DispatcherOperation.cs new file mode 100644 index 000000000..30195ed51 --- /dev/null +++ b/Perspex.Windows/Threading/DispatcherOperation.cs @@ -0,0 +1,159 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.Windows.Threading +{ + using System; + using System.Security; + + public enum DispatcherOperationStatus + { + Pending = 0, + Aborted = 1, + Completed = 2, + Executing = 3 + } + + public sealed class DispatcherOperation + { + private DispatcherOperationStatus status; + private DispatcherPriority priority; + private Dispatcher dispatcher; + private object result; + private Delegate delegateMethod; + private object[] delegateArgs; + + internal DispatcherOperation(Dispatcher dis, DispatcherPriority prio) + { + this.dispatcher = dis; + this.priority = prio; + if (this.Dispatcher.HasShutdownFinished) + { + this.status = DispatcherOperationStatus.Aborted; + } + else + { + this.status = DispatcherOperationStatus.Pending; + } + } + + internal DispatcherOperation(Dispatcher dis, DispatcherPriority prio, Delegate d) + : this(dis, prio) + { + this.delegateMethod = d; + } + + internal DispatcherOperation(Dispatcher dis, DispatcherPriority prio, Delegate d, object arg) + : this(dis, prio) + { + this.delegateMethod = d; + this.delegateArgs = new object[1]; + this.delegateArgs[0] = arg; + } + + internal DispatcherOperation(Dispatcher dis, DispatcherPriority prio, Delegate d, object arg, object[] args) + : this(dis, prio) + { + this.delegateMethod = d; + this.delegateArgs = new object[args.Length + 1]; + this.delegateArgs[0] = arg; + Array.Copy(args, 1, this.delegateArgs, 0, args.Length); + } + + public event EventHandler Completed; + + public DispatcherOperationStatus Status + { + get + { + return this.status; + } + + internal set + { + this.status = value; + } + } + + public Dispatcher Dispatcher + { + get + { + return this.dispatcher; + } + } + + public DispatcherPriority Priority + { + get + { + return this.priority; + } + + set + { + if (this.priority != value) + { + DispatcherPriority old = this.priority; + this.priority = value; + this.dispatcher.Reprioritize(this, old); + } + } + } + + public object Result + { + get + { + return this.result; + } + } + + public bool Abort() + { + this.status = DispatcherOperationStatus.Aborted; + throw new NotImplementedException(); + } + + public DispatcherOperationStatus Wait() + { + if (this.status == DispatcherOperationStatus.Executing) + { + throw new InvalidOperationException("Already executing"); + } + + throw new NotImplementedException(); + } + + [SecurityCritical] + public DispatcherOperationStatus Wait(TimeSpan timeout) + { + if (this.status == DispatcherOperationStatus.Executing) + { + throw new InvalidOperationException("Already executing"); + } + + throw new NotImplementedException(); + } + + internal void Invoke() + { + this.status = DispatcherOperationStatus.Executing; + + if (this.delegateMethod != null) + { + this.result = this.delegateMethod.DynamicInvoke(this.delegateArgs); + } + + this.status = DispatcherOperationStatus.Completed; + + if (this.Completed != null) + { + this.Completed(this, EventArgs.Empty); + } + } + } +} \ No newline at end of file diff --git a/Perspex.Windows/Window.cs b/Perspex.Windows/Window.cs new file mode 100644 index 000000000..8e076cb0d --- /dev/null +++ b/Perspex.Windows/Window.cs @@ -0,0 +1,149 @@ +namespace Perspex.Windows +{ + using System; + using System.ComponentModel; + using System.Diagnostics.CodeAnalysis; + using System.Runtime.InteropServices; + using Perspex.Controls; + using Perspex.Windows.Interop; + using SharpDX.Direct2D1; + using SharpDX.DXGI; + + public class Window : ContentControl + { + private UnmanagedMethods.WndProc wndProcDelegate; + + private string className; + + private Renderer renderer; + + public Window() + { + this.CreateWindow(); + + Size clientSize = this.ClientSize; + this.renderer = new Renderer(this.Handle, (int)clientSize.Width, (int)clientSize.Height); + } + + public Size ClientSize + { + get + { + UnmanagedMethods.RECT rect; + UnmanagedMethods.GetClientRect(this.Handle, out rect); + return new Size(rect.right, rect.bottom); + } + } + + public IntPtr Handle + { + get; + private set; + } + + public void Show() + { + UnmanagedMethods.ShowWindow(this.Handle, 4); + this.Measure(this.ClientSize); + this.Arrange(new Rect(this.ClientSize)); + this.renderer.Render(this); + } + + protected override Visual DefaultTemplate() + { + Border border = new Border(); + border.Background = new Perspex.Media.SolidColorBrush(0xff808080); + ContentPresenter contentPresenter = new ContentPresenter(); + contentPresenter.Bind(ContentPresenter.ContentProperty, this.GetObservable(ContentProperty)); + border.Content = contentPresenter; + return border; + } + + private void CreateWindow() + { + // Ensure that the delegate doesn't get garbage collected by storing it as a field. + this.wndProcDelegate = new UnmanagedMethods.WndProc(this.WndProc); + + this.className = Guid.NewGuid().ToString(); + + UnmanagedMethods.WNDCLASSEX wndClassEx = new UnmanagedMethods.WNDCLASSEX + { + cbSize = Marshal.SizeOf(typeof(UnmanagedMethods.WNDCLASSEX)), + style = 0, + lpfnWndProc = this.wndProcDelegate, + hInstance = Marshal.GetHINSTANCE(this.GetType().Module), + hCursor = UnmanagedMethods.LoadCursor(IntPtr.Zero, (int)UnmanagedMethods.Cursor.IDC_ARROW), + hbrBackground = (IntPtr)5, + lpszClassName = this.className, + }; + + ushort atom = UnmanagedMethods.RegisterClassEx(ref wndClassEx); + + if (atom == 0) + { + throw new Win32Exception(); + } + + this.Handle = UnmanagedMethods.CreateWindowEx( + 0, + atom, + null, + (int)UnmanagedMethods.WindowStyles.WS_OVERLAPPEDWINDOW, + UnmanagedMethods.CW_USEDEFAULT, + UnmanagedMethods.CW_USEDEFAULT, + UnmanagedMethods.CW_USEDEFAULT, + UnmanagedMethods.CW_USEDEFAULT, + IntPtr.Zero, + IntPtr.Zero, + IntPtr.Zero, + IntPtr.Zero); + + if (this.Handle == IntPtr.Zero) + { + throw new Win32Exception(); + } + } + + [SuppressMessage("Microsoft.StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Justification = "Using Win32 naming for consistency.")] + private IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam) + { + switch ((UnmanagedMethods.WindowsMessage)msg) + { + ////case UnmanagedMethods.WindowsMessage.WM_DESTROY: + //// this.OnClosed(); + //// break; + + ////case UnmanagedMethods.WindowsMessage.WM_KEYDOWN: + //// InputManager.Current.ProcessInput( + //// new RawKeyEventArgs( + //// keyboard, + //// RawKeyEventType.KeyDown, + //// KeyInterop.KeyFromVirtualKey((int)wParam))); + //// break; + + ////case UnmanagedMethods.WindowsMessage.WM_LBUTTONDOWN: + //// InputManager.Current.ProcessInput(new RawMouseEventArgs(mouse, RawMouseEventType.LeftButtonDown)); + //// break; + + ////case UnmanagedMethods.WindowsMessage.WM_LBUTTONUP: + //// InputManager.Current.ProcessInput(new RawMouseEventArgs(mouse, RawMouseEventType.LeftButtonUp)); + //// break; + + ////case UnmanagedMethods.WindowsMessage.WM_MOUSEMOVE: + //// InputManager.Current.ProcessInput(new RawMouseEventArgs(mouse, RawMouseEventType.Move)); + //// break; + + ////case UnmanagedMethods.WindowsMessage.WM_SIZE: + //// if (this.renderTarget != null) + //// { + //// this.renderTarget.Resize(new SharpDX.DrawingSize((int)lParam & 0xffff, (int)lParam >> 16)); + //// } + + //// this.OnResized(); + //// return IntPtr.Zero; + } + + return UnmanagedMethods.DefWindowProc(hWnd, msg, wParam, lParam); + } + } +} diff --git a/Perspex.Windows/packages.config b/Perspex.Windows/packages.config new file mode 100644 index 000000000..9bf3829fc --- /dev/null +++ b/Perspex.Windows/packages.config @@ -0,0 +1,12 @@ + + + + + + + + + + + + \ No newline at end of file diff --git a/Perspex.sln b/Perspex.sln new file mode 100644 index 000000000..3a84b3a0d --- /dev/null +++ b/Perspex.sln @@ -0,0 +1,40 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2013 +VisualStudioVersion = 12.0.21005.1 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Perspex", "Perspex\Perspex.csproj", "{3C9F40DA-D2A5-43A1-A272-E965876C6D46}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Perspex.Windows", "Perspex.Windows\Perspex.Windows.csproj", "{811A76CF-1CF6-440F-963B-BBE31BD72A82}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestApplication", "TestApplication\TestApplication.csproj", "{E3A1060B-50D0-44E8-88B6-F44EF2E5BD72}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Perspex.UnitTests", "Perspex.UnitTests\Perspex.UnitTests.csproj", "{2905FF23-53FB-45E6-AA49-6AF47A172056}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {3C9F40DA-D2A5-43A1-A272-E965876C6D46}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {3C9F40DA-D2A5-43A1-A272-E965876C6D46}.Debug|Any CPU.Build.0 = Debug|Any CPU + {3C9F40DA-D2A5-43A1-A272-E965876C6D46}.Release|Any CPU.ActiveCfg = Release|Any CPU + {3C9F40DA-D2A5-43A1-A272-E965876C6D46}.Release|Any CPU.Build.0 = Release|Any CPU + {811A76CF-1CF6-440F-963B-BBE31BD72A82}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {811A76CF-1CF6-440F-963B-BBE31BD72A82}.Debug|Any CPU.Build.0 = Debug|Any CPU + {811A76CF-1CF6-440F-963B-BBE31BD72A82}.Release|Any CPU.ActiveCfg = Release|Any CPU + {811A76CF-1CF6-440F-963B-BBE31BD72A82}.Release|Any CPU.Build.0 = Release|Any CPU + {E3A1060B-50D0-44E8-88B6-F44EF2E5BD72}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {E3A1060B-50D0-44E8-88B6-F44EF2E5BD72}.Debug|Any CPU.Build.0 = Debug|Any CPU + {E3A1060B-50D0-44E8-88B6-F44EF2E5BD72}.Release|Any CPU.ActiveCfg = Release|Any CPU + {E3A1060B-50D0-44E8-88B6-F44EF2E5BD72}.Release|Any CPU.Build.0 = Release|Any CPU + {2905FF23-53FB-45E6-AA49-6AF47A172056}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {2905FF23-53FB-45E6-AA49-6AF47A172056}.Debug|Any CPU.Build.0 = Debug|Any CPU + {2905FF23-53FB-45E6-AA49-6AF47A172056}.Release|Any CPU.ActiveCfg = Release|Any CPU + {2905FF23-53FB-45E6-AA49-6AF47A172056}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Perspex/Controls/Border.cs b/Perspex/Controls/Border.cs new file mode 100644 index 000000000..b16b7781a --- /dev/null +++ b/Perspex/Controls/Border.cs @@ -0,0 +1,27 @@ +namespace Perspex.Controls +{ + using System.Diagnostics.Contracts; + using Perspex.Media; + + public class Border : Decorator + { + public static readonly PerspexProperty BackgroundProperty = + PerspexProperty.Register("Background"); + + public Brush Background + { + get { return this.GetValue(BackgroundProperty); } + set { this.SetValue(BackgroundProperty, value); } + } + + public override void Render(IDrawingContext context) + { + Brush background = this.Background; + + if (background != null) + { + context.FillRectange(background, new Rect(this.Bounds.Size)); + } + } + } +} diff --git a/Perspex/Controls/ContentControl.cs b/Perspex/Controls/ContentControl.cs new file mode 100644 index 000000000..8fc311d3e --- /dev/null +++ b/Perspex/Controls/ContentControl.cs @@ -0,0 +1,46 @@ +namespace Perspex.Controls +{ + using System.Linq; + + public abstract class ContentControl : TemplatedControl + { + public static readonly PerspexProperty ContentProperty = + PerspexProperty.Register("Content"); + + public object Content + { + get { return this.GetValue(ContentProperty); } + set { this.SetValue(ContentProperty, value); } + } + + protected override Size ArrangeContent(Size finalSize) + { + Control child = this.VisualChildren.SingleOrDefault() as Control; + + if (child != null) + { + child.Arrange(new Rect(finalSize)); + return child.Bounds.Size; + } + else + { + return new Size(); + } + } + + protected override Size MeasureContent(Size availableSize) + { + Control child = this.VisualChildren.SingleOrDefault() as Control; + + if (child != null) + { + child.Measure(availableSize); + return child.DesiredSize.Value; + } + else + { + return new Size(); + } + } + } +} diff --git a/Perspex/Controls/ContentPresenter.cs b/Perspex/Controls/ContentPresenter.cs new file mode 100644 index 000000000..72671bfb7 --- /dev/null +++ b/Perspex/Controls/ContentPresenter.cs @@ -0,0 +1,131 @@ +namespace Perspex.Controls +{ + using System; + using System.Collections.Generic; + using System.Linq; + + public class ContentPresenter : Control + { + public static readonly PerspexProperty ContentProperty = + ContentControl.ContentProperty.AddOwner(); + + public static readonly PerspexProperty> DataTemplateProperty = + PerspexProperty.Register>("DataTemplate"); + + private Visual visualChild; + + public object Content + { + get { return this.GetValue(ContentProperty); } + set { this.SetValue(ContentProperty, value); } + } + + public Func DataTemplate + { + get { return this.GetValue(DataTemplateProperty); } + set { this.SetValue(DataTemplateProperty, value); } + } + + public override IEnumerable VisualChildren + { + get + { + object content = this.Content; + var dataTemplate = this.DataTemplate; + + if (this.visualChild == null && content != null) + { + if (content is Visual) + { + this.visualChild = (Visual)content; + } + else if (dataTemplate != null) + { + this.visualChild = dataTemplate(this); + } + else + { + this.visualChild = new TextBlock + { + Text = content.ToString(), + }; + } + } + + return Enumerable.Repeat(this.visualChild, this.visualChild != null ? 1 : 0); + } + } + + protected override Size ArrangeContent(Size finalSize) + { + Control child = this.VisualChildren.SingleOrDefault() as Control; + + if (child != null) + { + double left; + double top; + double width; + double height; + + switch (child.HorizontalAlignment) + { + case HorizontalAlignment.Left: + left = 0; + width = child.DesiredSize.Value.Width; + break; + case HorizontalAlignment.Center: + left = (finalSize.Width / 2) - (child.DesiredSize.Value.Width / 2); + width = child.DesiredSize.Value.Width; + break; + case HorizontalAlignment.Right: + left = finalSize.Width - child.DesiredSize.Value.Width; + width = child.DesiredSize.Value.Width; + break; + default: + left = 0; + width = finalSize.Width; + break; + } + + switch (child.VerticalAlignment) + { + case VerticalAlignment.Top: + top = 0; + height = child.DesiredSize.Value.Height; + break; + case VerticalAlignment.Center: + top = (finalSize.Height / 2) - (child.DesiredSize.Value.Height / 2); + height = child.DesiredSize.Value.Height; + break; + case VerticalAlignment.Bottom: + top = finalSize.Height - child.DesiredSize.Value.Height; + height = child.DesiredSize.Value.Height; + break; + default: + top = 0; + height = finalSize.Height; + break; + } + + child.Arrange(new Rect(left, top, width, height)); + } + + return finalSize; + } + + protected override Size MeasureContent(Size availableSize) + { + Control child = this.VisualChildren.SingleOrDefault() as Control; + + if (child != null) + { + child.Measure(availableSize); + return child.DesiredSize.Value; + } + else + { + return new Size(); + } + } + } +} diff --git a/Perspex/Controls/Control.cs b/Perspex/Controls/Control.cs new file mode 100644 index 000000000..6d1241b54 --- /dev/null +++ b/Perspex/Controls/Control.cs @@ -0,0 +1,76 @@ +namespace Perspex.Controls +{ + using System.Diagnostics.Contracts; + + public enum HorizontalAlignment + { + Stretch, + Left, + Center, + Right, + } + + public enum VerticalAlignment + { + Stretch, + Top, + Center, + Bottom, + } + + public abstract class Control : Visual + { + public static readonly PerspexProperty HorizontalAlignmentProperty = + PerspexProperty.Register("HorizontalAlignment"); + + public static readonly PerspexProperty VerticalAlignmentProperty = + PerspexProperty.Register("VerticalAlignment"); + + public static readonly PerspexProperty MarginProperty = + PerspexProperty.Register("Margin"); + + public Size? DesiredSize + { + get; + set; + } + + public HorizontalAlignment HorizontalAlignment + { + get { return this.GetValue(HorizontalAlignmentProperty); } + set { this.SetValue(HorizontalAlignmentProperty, value); } + } + + public VerticalAlignment VerticalAlignment + { + get { return this.GetValue(VerticalAlignmentProperty); } + set { this.SetValue(VerticalAlignmentProperty, value); } + } + + public Thickness Margin + { + get { return this.GetValue(MarginProperty); } + set { this.SetValue(MarginProperty, value); } + } + + public void Arrange(Rect rect) + { + this.Bounds = new Rect( + rect.Position, + this.ArrangeContent(rect.Size.Deflate(this.Margin).Constrain(rect.Size))); + } + + public void Measure(Size availableSize) + { + availableSize = availableSize.Deflate(this.Margin); + this.DesiredSize = this.MeasureContent(availableSize).Constrain(availableSize); + } + + protected virtual Size ArrangeContent(Size finalSize) + { + return finalSize; + } + + protected abstract Size MeasureContent(Size availableSize); + } +} diff --git a/Perspex/Controls/Decorator.cs b/Perspex/Controls/Decorator.cs new file mode 100644 index 000000000..9f1a8d64b --- /dev/null +++ b/Perspex/Controls/Decorator.cs @@ -0,0 +1,54 @@ +namespace Perspex.Controls +{ + using System; + using System.Collections.Generic; + using System.Linq; + + public abstract class Decorator : Control + { + public static readonly PerspexProperty ContentProperty = + PerspexProperty.Register("Content"); + + public Control Content + { + get { return this.GetValue(ContentProperty); } + set { this.SetValue(ContentProperty, value); } + } + + public override IEnumerable VisualChildren + { + get + { + Control content = this.Content; + return Enumerable.Repeat(content, content != null ? 1 : 0); + } + } + + protected override Size ArrangeContent(Size finalSize) + { + Control content = this.Content; + + if (content != null) + { + content.Arrange(new Rect(finalSize)); + } + + return finalSize; + } + + protected override Size MeasureContent(Size availableSize) + { + Control content = this.Content; + + if (content != null) + { + content.Measure(availableSize); + return content.DesiredSize.Value; + } + else + { + return new Size(); + } + } + } +} diff --git a/Perspex/Controls/TemplatedControl.cs b/Perspex/Controls/TemplatedControl.cs new file mode 100644 index 000000000..884e658b6 --- /dev/null +++ b/Perspex/Controls/TemplatedControl.cs @@ -0,0 +1,47 @@ +namespace Perspex.Controls +{ + using System; + using System.Collections.Generic; + using System.Linq; + using Perspex.Media; + + public abstract class TemplatedControl : Control + { + public static readonly PerspexProperty> TemplateProperty = + PerspexProperty.Register>("Template"); + + private Visual visualChild; + + public TemplatedControl() + { + this.Template = owner => this.DefaultTemplate(); + } + + public Func Template + { + get { return this.GetValue(TemplateProperty); } + set { this.SetValue(TemplateProperty, value); } + } + + public override IEnumerable VisualChildren + { + get + { + var template = this.Template; + + if (this.visualChild == null && template != null) + { + this.visualChild = template(this); + } + + return Enumerable.Repeat(this.visualChild, this.visualChild != null ? 1 : 0); + } + } + + public sealed override void Render(IDrawingContext context) + { + } + + protected abstract Visual DefaultTemplate(); + } +} diff --git a/Perspex/Controls/TextBlock.cs b/Perspex/Controls/TextBlock.cs new file mode 100644 index 000000000..943ae048c --- /dev/null +++ b/Perspex/Controls/TextBlock.cs @@ -0,0 +1,68 @@ +namespace Perspex.Controls +{ + using Perspex.Media; + + public class TextBlock : Control + { + public static readonly PerspexProperty BackgroundProperty = + Border.BackgroundProperty.AddOwner(); + + public static readonly PerspexProperty ForegroundProperty = + PerspexProperty.Register( + "Foreground", + defaultValue: new SolidColorBrush(0xff000000), + inherits: true); + + public static readonly PerspexProperty TextProperty = + PerspexProperty.Register("Text"); + + public Brush Background + { + get { return this.GetValue(BackgroundProperty); } + set { this.SetValue(BackgroundProperty, value); } + } + + public Brush Foreground + { + get { return this.GetValue(ForegroundProperty); } + set { this.SetValue(ForegroundProperty, value); } + } + + public string Text + { + get { return this.GetValue(TextProperty); } + set { this.SetValue(TextProperty, value); } + } + + private FormattedText FormattedText + { + get + { + return new FormattedText + { + FontFamilyName = "Segoe UI", + FontSize = 18, + Text = this.Text, + }; + } + } + + public override void Render(IDrawingContext context) + { + Brush background = this.Background; + + if (background != null) + { + context.FillRectange(background, this.Bounds); + } + + context.DrawText(this.Foreground, this.Bounds, this.FormattedText); + } + + protected override Size MeasureContent(Size availableSize) + { + ITextService service = ServiceLocator.Get(); + return service.Measure(this.FormattedText); + } + } +} diff --git a/Perspex/Media/Brush.cs b/Perspex/Media/Brush.cs new file mode 100644 index 000000000..7f6dce63e --- /dev/null +++ b/Perspex/Media/Brush.cs @@ -0,0 +1,15 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.Media +{ + /// + /// Describes how an area is painted. + /// + public abstract class Brush + { + } +} diff --git a/Perspex/Media/Color.cs b/Perspex/Media/Color.cs new file mode 100644 index 000000000..cf4a77973 --- /dev/null +++ b/Perspex/Media/Color.cs @@ -0,0 +1,110 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.Media +{ + /// + /// An ARGB color. + /// + public struct Color + { + /// + /// Gets or sets the Alpha component of the color. + /// + public byte A { get; set; } + + /// + /// Gets or sets the Red component of the color. + /// + public byte R { get; set; } + + /// + /// Gets or sets the Green component of the color. + /// + public byte G { get; set; } + + /// + /// Gets or sets the Blue component of the color. + /// + public byte B { get; set; } + + /// + /// Creates a from alpha, red, green and blue components. + /// + /// The alpha component. + /// The red component. + /// The green component. + /// The blue component. + /// The color. + public static Color FromArgb(byte a, byte r, byte g, byte b) + { + return new Color + { + A = a, + R = r, + G = g, + B = b, + }; + } + + /// + /// Creates a from red, green and blue components. + /// + /// The red component. + /// The green component. + /// The blue component. + /// The color. + public static Color FromRgb(byte r, byte g, byte b) + { + return new Color + { + A = 0xff, + R = r, + G = g, + B = b, + }; + } + + /// + /// Creates a from an integer. + /// + /// The integer value. + /// The color. + public static Color FromUInt32(uint value) + { + return new Color + { + A = (byte)((value >> 24) & 0xff), + R = (byte)((value >> 16) & 0xff), + G = (byte)((value >> 8) & 0xff), + B = (byte)(value & 0xff), + }; + } + + /// + /// Returns the string representation of the color. + /// + /// + /// The string representation of the color. + /// + public override string ToString() + { + uint rgb = ((uint)this.A << 24) | ((uint)this.R << 16) | ((uint)this.G << 8) | (uint)this.B; + return string.Format("#{0:x8}", rgb); + } + + /// + /// Returns the integer representation of the color. + /// + /// + /// The integer representation of the color. + /// + public uint ToUint32() + { + return ((uint)this.A << 24) | ((uint)this.R << 16) | ((uint)this.G << 8) | (uint)this.B; + } + } +} diff --git a/Perspex/Media/FormattedText.cs b/Perspex/Media/FormattedText.cs new file mode 100644 index 000000000..556d2a9f9 --- /dev/null +++ b/Perspex/Media/FormattedText.cs @@ -0,0 +1,17 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.Media +{ + public class FormattedText + { + public string FontFamilyName { get; set; } + + public double FontSize { get; set; } + + public string Text { get; set; } + } +} diff --git a/Perspex/Media/IDrawingContext.cs b/Perspex/Media/IDrawingContext.cs new file mode 100644 index 000000000..b8ba68625 --- /dev/null +++ b/Perspex/Media/IDrawingContext.cs @@ -0,0 +1,36 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.Media +{ + /// + /// Defines the interface through which drawing occurs. + /// + public interface IDrawingContext + { + /// + /// Draws the outline of a rectangle. + /// + /// The pen. + /// The rectangle bounds. + void DrawRectange(Pen pen, Rect rect); + + /// + /// Draws text. + /// + /// The foreground brush. + /// The bounding rectangle. + /// The text. + void DrawText(Brush foreground, Rect rect, FormattedText text); + + /// + /// Draws a filled rectangle. + /// + /// The brush. + /// The rectangle bounds. + void FillRectange(Brush brush, Rect rect); + } +} diff --git a/Perspex/Media/ITextService.cs b/Perspex/Media/ITextService.cs new file mode 100644 index 000000000..0d44ba01b --- /dev/null +++ b/Perspex/Media/ITextService.cs @@ -0,0 +1,7 @@ +namespace Perspex.Media +{ + public interface ITextService + { + Size Measure(FormattedText text); + } +} diff --git a/Perspex/Media/Pen.cs b/Perspex/Media/Pen.cs new file mode 100644 index 000000000..5e73c4033 --- /dev/null +++ b/Perspex/Media/Pen.cs @@ -0,0 +1,46 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.Media +{ + /// + /// Describes how a stroke is drawn. + /// + public class Pen + { + /// + /// Initializes a new instance of the class. + /// + /// The brush used to draw. + /// The stroke thickness. + public Pen(Brush brush, double thickness) + { + this.Brush = brush; + this.Thickness = thickness; + } + + /// + /// Initializes a new instance of the class. + /// + /// The stroke color. + /// The stroke thickness. + public Pen(uint color, double thickness) + { + this.Brush = new SolidColorBrush(color); + this.Thickness = thickness; + } + + /// + /// Gets the brush used to draw the stroke. + /// + public Brush Brush { get; private set; } + + /// + /// Gets the stroke thickness. + /// + public double Thickness { get; private set; } + } +} diff --git a/Perspex/Media/SolidColorBrush.cs b/Perspex/Media/SolidColorBrush.cs new file mode 100644 index 000000000..6bd549987 --- /dev/null +++ b/Perspex/Media/SolidColorBrush.cs @@ -0,0 +1,41 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex.Media +{ + /// + /// Fills an area with a solid color. + /// + public class SolidColorBrush : Brush + { + /// + /// Initializes a new instance of the class. + /// + /// The color to use. + public SolidColorBrush(Color color) + { + this.Color = color; + } + + /// + /// Initializes a new instance of the class. + /// + /// The color to use. + public SolidColorBrush(uint color) + : this(Color.FromUInt32(color)) + { + } + + /// + /// Gets the color of the brush. + /// + public Color Color + { + get; + private set; + } + } +} diff --git a/Perspex/Perspex.csproj b/Perspex/Perspex.csproj new file mode 100644 index 000000000..24155f752 --- /dev/null +++ b/Perspex/Perspex.csproj @@ -0,0 +1,142 @@ + + + + + 11.0 + Debug + AnyCPU + {3C9F40DA-D2A5-43A1-A272-E965876C6D46} + Library + Properties + Perspex + Perspex + v4.5 + Profile7 + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + 1 + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + True + False + True + False + False + True + True + True + False + False + False + True + True + False + False + False + True + False + True + True + False + False + + + + + + + + True + False + Full + %28none%29 + 0 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ..\packages\Rx-Core.2.1.30214.0\lib\Portable-Net45+WinRT45+WP8\System.Reactive.Core.dll + + + ..\packages\Rx-Interfaces.2.1.30214.0\lib\Portable-Net45+WinRT45+WP8\System.Reactive.Interfaces.dll + + + ..\packages\Rx-Linq.2.1.30214.0\lib\Portable-Net45+WinRT45+WP8\System.Reactive.Linq.dll + + + + + + + + + ..\packages\StyleCop.MSBuild.4.7.46.0\tools\StyleCop.targets + + + + Failed to import StyleCop.MSBuild targets from '$(StyleCopMSBuildTargetsFile)'. The StyleCop.MSBuild package was either missing or incomplete when the project was loaded. Ensure that the package is present and then restart the build. If you are using an IDE (e.g. Visual Studio), reload the project before restarting the build. + Failed to import StyleCop.MSBuild targets from '$(StyleCopMSBuildTargetsFile)'. The StyleCop.MSBuild package was either missing or incomplete when the project was loaded (but is now present). To fix this, restart the build. If you are using an IDE (e.g. Visual Studio), reload the project before restarting the build. + Failed to import StyleCop.MSBuild targets from '$(StyleCopMSBuildTargetsFile)'. The StyleCop.MSBuild package was either missing or incomplete when the project was loaded. To fix this, restore the package and then restart the build. If you are using an IDE (e.g. Visual Studio), you may need to reload the project before restarting the build. Note that regular NuGet package restore (during build) does not work with this package because the package needs to be present before the project is loaded. If this is an automated build (e.g. CI server), you may want to ensure that the build process restores the StyleCop.MSBuild package before the project is built. + Failed to import StyleCop.MSBuild targets from '$(StyleCopMSBuildTargetsFile)'. The StyleCop.MSBuild package was either missing or incomplete when the project was loaded (but is now present). To fix this, restart the build. If you are using an IDE (e.g. Visual Studio), reload the project before restarting the build. Note that when using regular NuGet package restore (during build) the package will not be available for the initial build because the package needs to be present before the project is loaded. If package restore executes successfully in the intitial build then the package will be available for subsequent builds. If this is an automated build (e.g. CI server), you may want to ensure that the build process restores the StyleCop.MSBuild package before the initial build. + + + + + + + + + + + + + StyleCopMSBuildTargetsNotFound;$(PrepareForBuildDependsOn) + + \ No newline at end of file diff --git a/Perspex/PerspexObject.cs b/Perspex/PerspexObject.cs new file mode 100644 index 000000000..09f3df787 --- /dev/null +++ b/Perspex/PerspexObject.cs @@ -0,0 +1,352 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 Tricycle. All rights reserved. +// +// ----------------------------------------------------------------------- + +namespace Perspex +{ + using System; + using System.Collections.Generic; + using System.Diagnostics.Contracts; + using System.Linq; + using System.Reactive; + using System.Reactive.Linq; + using System.Reflection; + + /// + /// An object with support. + /// + /// + /// This class is analogous to DependencyObject in WPF. + /// + public class PerspexObject + { + /// + /// The registered properties by type. + /// + private static Dictionary> registered = + new Dictionary>(); + + /// + /// The parent object that inherited values are inherited from. + /// + private PerspexObject inheritanceParent; + + /// + /// The set values on this object. + /// + private Dictionary values = + new Dictionary(); + + /// + /// The current bindings on this object. + /// + private Dictionary bindings = + new Dictionary(); + + /// + /// Raised when a value changes on this object/ + /// + public event EventHandler PropertyChanged; + + /// + /// Gets or sets the parent object that inherited values + /// are inherited from. + /// + protected PerspexObject InheritanceParent + { + get + { + return this.inheritanceParent; + } + + set + { + if (this.inheritanceParent != value) + { + if (this.inheritanceParent != null) + { + this.inheritanceParent.PropertyChanged -= this.ParentPropertyChanged; + } + + var inherited = (from property in GetProperties(this.GetType()) + where property.Inherits + select new + { + Property = property, + Value = this.GetValue(property), + }).ToList(); + + this.inheritanceParent = value; + + foreach (var i in inherited) + { + object newValue = this.GetValue(i.Property); + + if (!object.Equals(i.Value, newValue)) + { + this.RaisePropertyChanged(i.Property, i.Value, newValue); + } + } + + if (this.inheritanceParent != null) + { + this.inheritanceParent.PropertyChanged += this.ParentPropertyChanged; + } + } + } + } + + /// + /// Gets all s registered on a type. + /// + /// The type. + /// A collection of definitions. + public static IEnumerable GetProperties(Type type) + { + Contract.Requires(type != null); + + TypeInfo i = type.GetTypeInfo(); + + while (type != null) + { + List list; + + if (registered.TryGetValue(type, out list)) + { + foreach (PerspexProperty p in list) + { + yield return p; + } + } + + type = type.GetTypeInfo().BaseType; + } + } + + /// + /// Registers a on a type. + /// + /// The type. + /// The property. + /// + /// You won't usually want to call this method directly, instead use the + /// method. + /// + public static void Register(Type type, PerspexProperty property) + { + Contract.Requires(type != null); + Contract.Requires(property != null); + + List list; + + if (!registered.TryGetValue(type, out list)) + { + list = new List(); + registered.Add(type, list); + } + + if (!list.Contains(property)) + { + list.Add(property); + } + } + + /// + /// Binds a property on this object to an observable. + /// + /// The type of the property. + /// The target property. + /// The observable. + /// A disposable binding. + public void Bind(PerspexProperty target, IObservable source) + { + Contract.Requires(target != null); + Contract.Requires(source != null); + + this.ClearBinding(target); + + IDisposable binding = source.Subscribe(Observer.Create(value => + { + this.SetValue(target, value); + })); + + this.bindings.Add(target, binding); + } + + /// + /// Clears a binding on a , leaving the last bound value in + /// place. + /// + /// The property. + public void ClearBinding(PerspexProperty property) + { + Contract.Requires(property != null); + IDisposable binding; + + if (this.bindings.TryGetValue(property, out binding)) + { + binding.Dispose(); + this.bindings.Remove(property); + } + } + + /// + /// Clears a value, including its bindings. + /// + /// The property. + public void ClearValue(PerspexProperty property) + { + Contract.Requires(property != null); + this.ClearBinding(property); + this.values.Remove(property); + } + + /// + /// Gets an observable for a . + /// + /// + /// + /// + public IObservable GetObservable(PerspexProperty property) + { + return Observable.Create(observer => + { + EventHandler handler = (s, e) => + { + if (e.Property == property) + { + observer.OnNext((T)e.NewValue); + } + }; + + this.PropertyChanged += handler; + observer.OnNext(this.GetValue(property)); + + return () => + { + this.PropertyChanged -= handler; + }; + }); + } + + /// + /// Gets a value. + /// + /// The property. + /// The value. + public object GetValue(PerspexProperty property) + { + Contract.Requires(property != null); + + object value; + + if (!this.values.TryGetValue(property, out value)) + { + if (property.Inherits && this.inheritanceParent != null) + { + value = this.inheritanceParent.GetValue(property); + } + else + { + value = property.GetDefaultValue(this.GetType()); + } + } + + return value; + } + + /// + /// Gets a value. + /// + /// The property. + /// The value. + public T GetValue(PerspexProperty property) + { + Contract.Requires(property != null); + + return (T)this.GetValue((PerspexProperty)property); + } + + /// + /// Gets a value. + /// + /// The type of the property. + /// The property. + /// The value. + public T GetValue(ReadOnlyPerspexProperty property) + { + Contract.Requires(property != null); + + return (T)this.GetValue(property.Property); + } + + /// + /// Checks whether a is set on this object. + /// + /// + /// + public bool IsSet(PerspexProperty property) + { + Contract.Requires(property != null); + + return this.values.ContainsKey(property); + } + + /// + /// Sets a value. + /// + /// The type of the property. + /// The property. + /// The value. + public void SetValue(PerspexProperty property, T value) + { + Contract.Requires(property != null); + + this.ClearBinding(property); + + T oldValue = this.GetValue(property); + + if (!object.Equals(oldValue, value)) + { + this.values[property] = value; + this.RaisePropertyChanged(property, oldValue, value); + } + } + + /// + /// Called when a property is changed on the current . + /// + /// The event sender. + /// The event args. + /// + /// Checks for changes in an inherited property value. + /// + private void ParentPropertyChanged(object sender, PerspexPropertyChangedEventArgs e) + { + if (e.Property.Inherits && !this.IsSet(e.Property)) + { + this.RaisePropertyChanged(e.Property, e.OldValue, e.NewValue); + } + } + + /// + /// Raises the event. + /// + /// The property that has changed. + /// The old property value. + /// The new property value. + private void RaisePropertyChanged(PerspexProperty property, object oldValue, object newValue) + { + Contract.Requires(property != null); + + if (this.PropertyChanged != null) + { + this.PropertyChanged( + this, + new PerspexPropertyChangedEventArgs(property, oldValue, newValue)); + } + } + } +} diff --git a/Perspex/PerspexProperty.cs b/Perspex/PerspexProperty.cs new file mode 100644 index 000000000..5e752708a --- /dev/null +++ b/Perspex/PerspexProperty.cs @@ -0,0 +1,186 @@ +namespace Perspex +{ + using System; + using System.Collections.Generic; + using System.Diagnostics.Contracts; + using System.Linq; + using System.Reflection; + using System.Text; + using System.Threading.Tasks; + + /// + /// A perspex property. + /// + /// + /// This class is analogous to DependencyProperty in WPF. + /// + public class PerspexProperty + { + /// + /// The default values for the property, by type. + /// + private Dictionary defaultValues = new Dictionary(); + + /// + /// Initializes a new instance of the class. + /// + /// The name of the property. + /// The type of the property's value. + /// The type of the class that registers the property. + /// The default value of the property. + /// Whether the property inherits its value. + public PerspexProperty( + string name, + Type valueType, + Type ownerType, + object defaultValue, + bool inherits) + { + Contract.Requires(name != null); + Contract.Requires(valueType != null); + Contract.Requires(ownerType != null); + + this.Name = name; + this.ValueType = valueType; + this.OwnerType = ownerType; + this.Inherits = inherits; + this.defaultValues.Add(ownerType, defaultValue); + } + + /// + /// The name of the property. + /// + public string Name { get; private set; } + + /// + /// The type of the property's value. + /// + public Type ValueType { get; private set; } + + /// + /// The type of the class that registers the property. + /// + public Type OwnerType { get; private set; } + + /// + /// Whether the property inherits its value. + /// + public bool Inherits { get; private set; } + + /// + /// Registers a . + /// + /// The type of the class that is registering the property. + /// The type of the property's value. + /// The name of the property. + /// The default value of the property. + /// Whether the property inherits its value. + /// + public static PerspexProperty Register( + string name, + TValue defaultValue = default(TValue), + bool inherits = false) + where TOwner : PerspexObject + { + Contract.Requires(name != null); + + PerspexProperty result = new PerspexProperty( + name, + typeof(TOwner), + defaultValue, + inherits); + + PerspexObject.Register(typeof(TOwner), result); + + return result; + } + + /// + /// Gets the default value for the property on the specified type. + /// + /// The type. + /// The default value. + public object GetDefaultValue(Type type) + { + Contract.Requires(type != null); + + while (type != null) + { + object result; + + if (this.defaultValues.TryGetValue(type, out result)) + { + return result; + } + + type = type.GetTypeInfo().BaseType; + } + + return this.defaultValues[this.OwnerType]; + } + + /// + /// Gets the default value for the property on the specified type. + /// + /// The type. + /// The default value. + public void OverrideDefaultValue(Type type, object defaultValue) + { + Contract.Requires(type != null); + + // TODO: Ensure correct type. + + if (this.defaultValues.ContainsKey(type)) + { + throw new InvalidOperationException("Default value is already set for this property."); + } + + this.defaultValues.Add(type, defaultValue); + } + } + + /// + /// A typed perspex property. + /// + public class PerspexProperty : PerspexProperty + { + /// + /// Initializes a new instance of the class. + /// + /// The name of the property. + /// The type of the class that registers the property. + /// The default value of the property. + /// Whether the property inherits its value. + public PerspexProperty( + string name, + Type ownerType, + TValue defaultValue, + bool inherits) + : base(name, typeof(TValue), ownerType, defaultValue, inherits) + { + Contract.Requires(name != null); + Contract.Requires(ownerType != null); + } + + /// + /// Registers the property on another type. + /// + /// The type of the additional owner. + /// The property. + public PerspexProperty AddOwner() + { + PerspexObject.Register(typeof(TOwner), this); + return this; + } + + /// + /// Gets the default value for the property on the specified type. + /// + /// The type. + /// The default value. + public TValue GetDefaultValue() + { + return (TValue)this.GetDefaultValue(typeof(T)); + } + } +} diff --git a/Perspex/PerspexPropertyChangedEventArgs.cs b/Perspex/PerspexPropertyChangedEventArgs.cs new file mode 100644 index 000000000..86c1f18eb --- /dev/null +++ b/Perspex/PerspexPropertyChangedEventArgs.cs @@ -0,0 +1,45 @@ +// ----------------------------------------------------------------------- +// +// Copyright 2013 MIT Licence. See licence.md for more information. +// +// ----------------------------------------------------------------------- + +namespace Perspex +{ + using System; + using System.Collections.Generic; + using System.Linq; + using System.Text; + using System.Threading.Tasks; + + /// + /// Provides information for a perspex property change. + /// + public class PerspexPropertyChangedEventArgs + { + public PerspexPropertyChangedEventArgs( + PerspexProperty property, + object oldValue, + object newValue) + { + this.Property = property; + this.OldValue = oldValue; + this.NewValue = newValue; + } + + /// + /// Gets the property that changed. + /// + public PerspexProperty Property { get; private set; } + + /// + /// Gets the old value of the property. + /// + public object OldValue { get; private set; } + + /// + /// Gets the new value of the property. + /// + public object NewValue { get; private set; } + } +} diff --git a/Perspex/Point.cs b/Perspex/Point.cs new file mode 100644 index 000000000..ab93b4856 --- /dev/null +++ b/Perspex/Point.cs @@ -0,0 +1,56 @@ +namespace Perspex +{ + using System.Globalization; + + /// + /// Defines a point. + /// + public struct Point + { + /// + /// The X position. + /// + private double x; + + /// + /// The Y position. + /// + private double y; + + /// + /// Initializes a new instance of the structure. + /// + /// The X position. + /// The Y position. + public Point(double x, double y) + { + this.x = x; + this.y = y; + } + + /// + /// Gets the X position. + /// + public double X + { + get { return this.x; } + } + + /// + /// Gets the Y position. + /// + public double Y + { + get { return this.y; } + } + + /// + /// Returns the string representation of the point. + /// + /// The string representation of the point. + public override string ToString() + { + return string.Format(CultureInfo.InvariantCulture, "{0}, {1}", this.x, this.y); + } + } +} diff --git a/Perspex/Properties/AssemblyInfo.cs b/Perspex/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..524a057d8 --- /dev/null +++ b/Perspex/Properties/AssemblyInfo.cs @@ -0,0 +1,28 @@ +using System.Reflection; +using System.Resources; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Perspex")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Perspex")] +[assembly: AssemblyCopyright("Copyright © 2013")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[assembly: NeutralResourcesLanguage("en")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Perspex/ReadOnlyPerspexProperty.cs b/Perspex/ReadOnlyPerspexProperty.cs new file mode 100644 index 000000000..db50c7b06 --- /dev/null +++ b/Perspex/ReadOnlyPerspexProperty.cs @@ -0,0 +1,12 @@ +namespace Perspex +{ + public class ReadOnlyPerspexProperty + { + public ReadOnlyPerspexProperty(PerspexProperty property) + { + this.Property = property; + } + + internal PerspexProperty Property { get; private set; } + } +} diff --git a/Perspex/Rect.cs b/Perspex/Rect.cs new file mode 100644 index 000000000..f4ef0cae3 --- /dev/null +++ b/Perspex/Rect.cs @@ -0,0 +1,147 @@ +namespace Perspex +{ + using System; + using System.Globalization; + + /// + /// Defines a rectangle. + /// + public struct Rect + { + /// + /// The X position. + /// + private double x; + + /// + /// The Y position. + /// + private double y; + + /// + /// The width. + /// + private double width; + + /// + /// The height. + /// + private double height; + + /// + /// Initializes a new instance of the structure. + /// + /// The X position. + /// The Y position. + /// The width. + /// The height. + public Rect(double x, double y, double width, double height) + { + this.x = x; + this.y = y; + this.width = width; + this.height = height; + } + + /// + /// Initializes a new instance of the structure. + /// + /// The size of the rectangle. + public Rect(Size size) + { + this.x = 0; + this.y = 0; + this.width = size.Width; + this.height = size.Height; + } + + /// + /// Initializes a new instance of the structure. + /// + /// The position of the rectangle. + /// The size of the rectangle. + public Rect(Point position, Size size) + { + this.x = position.X; + this.y = position.Y; + this.width = size.Width; + this.height = size.Height; + } + + /// + /// Gets the X position. + /// + public double X + { + get { return this.x; } + } + + /// + /// Gets the Y position. + /// + public double Y + { + get { return this.y; } + } + + /// + /// Gets the width. + /// + public double Width + { + get { return this.width; } + } + + /// + /// Gets the height. + /// + public double Height + { + get { return this.height; } + } + + /// + /// Gets the position of the rectangle. + /// + public Point Position + { + get { return new Point(this.x, this.y); } + } + + /// + /// Gets the size of the rectangle. + /// + public Size Size + { + get { return new Size(this.width, this.height); } + } + + /// + /// Deflates the rectangle by a . + /// + /// The thickness. + /// The deflated rectangle. + /// The deflated rectangle size cannot be less than 0. + public Rect Deflate(Thickness thickness) + { + return new Rect( + new Point(this.x + thickness.Left, this.y + thickness.Top), + this.Size.Deflate(thickness)); + } + + /// + /// Returns the string representation of the rectangle. + /// + /// The string representation of the rectangle. + public override string ToString() + { + return string.Format( + CultureInfo.InvariantCulture, + "{0}, {1}, {2}, {3}", + this.x, + this.y, + this.width, + this.height); + } + } +} diff --git a/Perspex/ServiceLocator.cs b/Perspex/ServiceLocator.cs new file mode 100644 index 000000000..225b019d9 --- /dev/null +++ b/Perspex/ServiceLocator.cs @@ -0,0 +1,24 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Perspex +{ + public static class ServiceLocator + { + private static Dictionary> services = + new Dictionary>(); + + public static T Get() + { + return (T)services[typeof(T)](); + } + + public static void Register(Func func) + { + services.Add(typeof(T), () => (object)func()); + } + } +} diff --git a/Perspex/Size.cs b/Perspex/Size.cs new file mode 100644 index 000000000..35b3ce7ad --- /dev/null +++ b/Perspex/Size.cs @@ -0,0 +1,94 @@ +namespace Perspex +{ + using System; + using System.Globalization; + + /// + /// Defines a size. + /// + public struct Size + { + /// + /// The width. + /// + private double width; + + /// + /// The height. + /// + private double height; + + /// + /// Initializes a new instance of the structure. + /// + /// The width. + /// The height. + public Size(double width, double height) + { + this.width = width; + this.height = height; + } + + /// + /// Gets the width. + /// + public double Width + { + get { return this.width; } + } + + /// + /// Gets the height. + /// + public double Height + { + get { return this.height; } + } + + /// + /// Constrains the size. + /// + /// The size to constrain to. + /// The constrained size. + public Size Constrain(Size constraint) + { + return new Size( + Math.Min(this.width, constraint.width), + Math.Min(this.height, constraint.height)); + } + + /// + /// Deflates the size by a . + /// + /// The thickness. + /// The deflated size. + /// The deflated size cannot be less than 0. + public Size Deflate(Thickness thickness) + { + return new Size( + Math.Max(0, this.width - thickness.Left - thickness.Right), + Math.Max(0, this.height - thickness.Top - thickness.Bottom)); + } + + /// + /// Inflates the size by a . + /// + /// The thickness. + /// The inflated size. + public Size Inflate(Thickness thickness) + { + return new Size( + this.width + thickness.Left + thickness.Right, + this.height + thickness.Top + thickness.Bottom); + } + + /// + /// Returns the string representation of the size. + /// + /// The string representation of the size + public override string ToString() + { + return string.Format(CultureInfo.InvariantCulture, "{0}, {1}", this.width, this.height); + } + } +} diff --git a/Perspex/Thickness.cs b/Perspex/Thickness.cs new file mode 100644 index 000000000..442cfe4e6 --- /dev/null +++ b/Perspex/Thickness.cs @@ -0,0 +1,163 @@ +namespace Perspex +{ + using System; + using System.Diagnostics.Contracts; + + public struct Thickness + { + /// + /// The thickness on the left. + /// + private double left; + + /// + /// The thickness on the top. + /// + private double top; + + /// + /// The thickness on the right. + /// + private double right; + + /// + /// The thickness on the bottom. + /// + private double bottom; + + /// + /// Initializes a new instance of the structure. + /// + /// The length that should be applied to all sides. + public Thickness(double uniformLength) + { + Contract.Requires(uniformLength >= 0); + + this.left = this.top = this.right = this.bottom = uniformLength; + } + + /// + /// Initializes a new instance of the structure. + /// + /// The thickness on the left. + /// The thickness on the top. + /// The thickness on the right. + /// The thickness on the bottom. + public Thickness(double left, double top, double right, double bottom) + { + Contract.Requires(left >= 0); + Contract.Requires(top >= 0); + Contract.Requires(right >= 0); + Contract.Requires(bottom >= 0); + + this.left = left; + this.top = top; + this.right = right; + this.bottom = bottom; + } + + /// + /// Gets the thickness on the left. + /// + public double Left + { + get { return this.left; } + } + + /// + /// Gets the thickness on the top. + /// + public double Top + { + get { return this.top; } + } + + /// + /// Gets the thickness on the right. + /// + public double Right + { + get { return this.right; } + } + + /// + /// Gets the thickness on the bottom. + /// + public double Bottom + { + get { return this.bottom; } + } + + /// + /// Gets a value indicating whether all sides are set to 0. + /// + public bool IsEmpty + { + get { return this.Left == 0 && this.Top == 0 && this.Right == 0 && this.Bottom == 0; } + } + + /// + /// Compares two Thicknesses. + /// + /// The first thickness. + /// The second thickness. + /// The equality. + public static bool operator ==(Thickness a, Thickness b) + { + return a.Equals(b); + } + + /// + /// Compares two Thicknesses. + /// + /// The first thickness. + /// The second thickness. + /// The unequality. + public static bool operator !=(Thickness a, Thickness b) + { + return !a.Equals(b); + } + + /// + /// Adds two Thicknesses. + /// + /// The first thickness. + /// The second thickness. + /// The equality. + public static Thickness operator +(Thickness a, Thickness b) + { + return new Thickness( + a.Left + b.Left, + a.Top + b.Top, + a.Right + b.Right, + a.Bottom + b.Bottom); + } + + public override bool Equals(object obj) + { + if (obj is Thickness) + { + Thickness other = (Thickness)obj; + return this.Left == other.Left && + this.Top == other.Top && + this.Right == other.Right && + this.Bottom == other.Bottom; + } + + return false; + } + + public override int GetHashCode() + { + unchecked + { + int hash = 17; + hash = (hash * 23) + this.Left.GetHashCode(); + hash = (hash * 23) + this.Top.GetHashCode(); + hash = (hash * 23) + this.Right.GetHashCode(); + hash = (hash * 23) + this.Bottom.GetHashCode(); + return hash; + } + } + } +} diff --git a/Perspex/Visual.cs b/Perspex/Visual.cs new file mode 100644 index 000000000..dd5ea900e --- /dev/null +++ b/Perspex/Visual.cs @@ -0,0 +1,33 @@ +namespace Perspex +{ + using System; + using System.Collections.Generic; + using System.Diagnostics.Contracts; + using System.Linq; + using Perspex.Media; + + public abstract class Visual : PerspexObject + { + public static readonly ReadOnlyPerspexProperty BoundsProperty = + new ReadOnlyPerspexProperty(BoundsPropertyW); + + private static readonly PerspexProperty BoundsPropertyW = + PerspexProperty.Register("Bounds", new Rect()); + + public Rect Bounds + { + get { return this.GetValue(BoundsPropertyW); } + protected set { this.SetValue(BoundsPropertyW, value); } + } + + public virtual IEnumerable VisualChildren + { + get { return Enumerable.Empty(); } + } + + public virtual void Render(IDrawingContext context) + { + Contract.Requires(context != null); + } + } +} diff --git a/Perspex/packages.config b/Perspex/packages.config new file mode 100644 index 000000000..69ab7f7d8 --- /dev/null +++ b/Perspex/packages.config @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/TestApplication/App.config b/TestApplication/App.config new file mode 100644 index 000000000..8e1564635 --- /dev/null +++ b/TestApplication/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/TestApplication/Program.cs b/TestApplication/Program.cs new file mode 100644 index 000000000..364e1270d --- /dev/null +++ b/TestApplication/Program.cs @@ -0,0 +1,34 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Perspex; +using Perspex.Controls; +using Perspex.Media; +using Perspex.Windows; +using Perspex.Windows.Media; +using Perspex.Windows.Threading; +namespace TestApplication +{ + class Program + { + static void Main(string[] args) + { + ServiceLocator.Register(() => new TextService(new SharpDX.DirectWrite.Factory())); + + Window window = new Window(); + + window.Content = new TextBlock + { + Text = "Hello World", + Background = new SolidColorBrush(0xffffffff), + HorizontalAlignment = HorizontalAlignment.Center, + VerticalAlignment = VerticalAlignment.Center, + }; + + window.Show(); + Dispatcher.Run(); + } + } +} diff --git a/TestApplication/Properties/AssemblyInfo.cs b/TestApplication/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..5e8029017 --- /dev/null +++ b/TestApplication/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("TestApplication")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("TestApplication")] +[assembly: AssemblyCopyright("Copyright © 2013")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("f8dad012-f4ec-4b63-b64f-320901338290")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/TestApplication/TestApplication.csproj b/TestApplication/TestApplication.csproj new file mode 100644 index 000000000..ca5b64162 --- /dev/null +++ b/TestApplication/TestApplication.csproj @@ -0,0 +1,98 @@ + + + + + Debug + AnyCPU + {E3A1060B-50D0-44E8-88B6-F44EF2E5BD72} + Exe + Properties + TestApplication + TestApplication + v4.5 + 512 + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + False + ..\packages\SharpDX.2.5.0\lib\net40\SharpDX.dll + + + False + ..\packages\SharpDX.Direct2D1.2.5.0\lib\net40\SharpDX.Direct2D1.dll + + + False + ..\packages\SharpDX.DXGI.2.5.0\lib\net40\SharpDX.DXGI.dll + + + + + + False + ..\packages\Rx-Core.2.1.30214.0\lib\Net45\System.Reactive.Core.dll + + + False + ..\packages\Rx-Interfaces.2.1.30214.0\lib\Net45\System.Reactive.Interfaces.dll + + + False + ..\packages\Rx-Linq.2.1.30214.0\lib\Net45\System.Reactive.Linq.dll + + + ..\packages\Rx-PlatformServices.2.1.30214.0\lib\Net45\System.Reactive.PlatformServices.dll + + + + + + + + + + + + + + + + + + + {811a76cf-1cf6-440f-963b-bbe31bd72a82} + Perspex.Windows + + + {3c9f40da-d2a5-43a1-a272-e965876c6d46} + Perspex + + + + + \ No newline at end of file diff --git a/TestApplication/packages.config b/TestApplication/packages.config new file mode 100644 index 000000000..5f137a719 --- /dev/null +++ b/TestApplication/packages.config @@ -0,0 +1,11 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/packages/Rx-Core.2.1.30214.0/Rx-Core.2.1.30214.0.nupkg b/packages/Rx-Core.2.1.30214.0/Rx-Core.2.1.30214.0.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..dd5c0496b3e16d3febf045ae22428fac40531d64 GIT binary patch literal 499563 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 CJdr8RV1=750&#*vO?W12@9!*G&JYW}N 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 CJdr8RV1=750&#*vO?W12@9!*G&JYW}NUw7-U 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 z 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 O@EriJqW62jPyYoKHeaa# literal 0 HcmV?d00001 diff --git a/packages/Rx-Core.2.1.30214.0/Rx-Core.2.1.30214.0.nuspec b/packages/Rx-Core.2.1.30214.0/Rx-Core.2.1.30214.0.nuspec new file mode 100644 index 000000000..42baabb71 --- /dev/null +++ b/packages/Rx-Core.2.1.30214.0/Rx-Core.2.1.30214.0.nuspec @@ -0,0 +1,25 @@ + + + + Rx-Core + 2.1.30214.0 + Reactive Extensions - Core Library + Microsoft Corporation + Microsoft Corporation + http://go.microsoft.com/fwlink/?LinkID=261272 + http://go.microsoft.com/fwlink/?LinkID=261273 + http://go.microsoft.com/fwlink/?LinkId=261274 + true + Reactive Extensions Core Library containing base classes and scheduler infrastructure. + Microsoft Corporation © 2012 + en-us + Rx Reactive Extensions Observable LINQ Events + + + + + + + + + \ No newline at end of file diff --git a/packages/Rx-Core.2.1.30214.0/lib/Net40/System.Reactive.Core.XML b/packages/Rx-Core.2.1.30214.0/lib/Net40/System.Reactive.Core.XML new file mode 100644 index 000000000..8d92ad0d8 --- /dev/null +++ b/packages/Rx-Core.2.1.30214.0/lib/Net40/System.Reactive.Core.XML @@ -0,0 +1,2617 @@ + + + + System.Reactive.Core + + + +

+ The System.Reactive.PlatformServices namespace contains interfaces and classes used by the runtime infrastructure of Reactive Extensions. + Those are not intended to be used directly from user code and are subject to change in future releases of the product. + + + + + Provides a set of static methods for subscribing delegates to observables. + + + + + Subscribes to the observable sequence without specifying any handlers. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + IDisposable object used to unsubscribe from the observable sequence. + is null. + + + + Subscribes an element handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or or is null. + + + + Subscribes an observer to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer to subscribe to the sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or is null. + + + + Subscribes to the observable sequence without specifying any handlers, using a CancellationToken to support unsubscription. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + CancellationToken that can be signaled to unsubscribe from the source sequence. + is null. + + + + Subscribes an element handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or or is null. + + + + Subscribes to the specified source, re-routing synchronous exceptions during invocation of the Subscribe method to the observer's OnError channel. + This method is typically used when writing query operators. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer that will be passed to the observable sequence, and that will be used for exception propagation. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Provides a set of static methods for creating observers. + + + + + Creates an observer from a notification callback. + + The type of the elements received by the observer. + Action that handles a notification. + The observer object that invokes the specified handler using a notification corresponding to each message it receives. + is null. + + + + Creates a notification callback from an observer. + + The type of the elements received by the observer. + Observer object. + The action that forwards its input notification to the underlying observer. + is null. + + + + Creates an observer from the specified OnNext action. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + The observer object implemented using the given actions. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or or is null. + + + + Hides the identity of an observer. + + The type of the elements received by the source observer. + An observer whose identity to hide. + An observer that hides the identity of the specified observer. + is null. + + + + Checks access to the observer for grammar violations. This includes checking for multiple OnError or OnCompleted calls, as well as reentrancy in any of the observer methods. + If a violation is detected, an InvalidOperationException is thrown from the offending observer method call. + + The type of the elements received by the source observer. + The observer whose callback invocations should be checked for grammar violations. + An observer that checks callbacks invocations against the observer grammar and, if the checks pass, forwards those to the specified observer. + is null. + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently from multiple threads. This overload is useful when coordinating access to an observer. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload, passing true for the second parameter. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently. This overload is useful when coordinating access to an observer. + The parameter configures the type of lock used for synchronization. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + If set to true, reentrant observer callbacks will be queued up and get delivered to the observer in a sequential manner. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + When the parameter is set to false, behavior is identical to the overload which uses + a Monitor for synchronization. When the parameter is set to true, an + is used to queue up callbacks to the specified observer if a reentrant call is made. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently by multiple threads, using the specified gate object for use by a Monitor-based lock. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common gate object. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently, using the specified asynchronous lock to protect against concurrent and reentrant access. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common asynchronous lock. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + + + Schedules the invocation of observer methods on the given scheduler. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Scheduler to schedule observer messages on. + Observer whose messages are scheduled on the given scheduler. + or is null. + + + + Schedules the invocation of observer methods on the given synchonization context. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Synchonization context to schedule observer messages on. + Observer whose messages are scheduled on the given synchonization context. + or is null. + + + + Class to create an IObservable<T> instance from a delegate-based implementation of the Subscribe method. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObservable<T> interface. + + + If you don't need a named type to create an observable sequence (i.e. you rather need + an instance rather than a reusable type), use the Observable.Create method to create + an observable sequence with specified subscription behavior. + + The type of the elements in the sequence. + + + + Subscribes the given observer to the observable sequence. + + Observer that will receive notifications from the observable sequence. + Disposable object representing an observer's subscription to the observable sequence. + is null. + + + + Implement this method with the core subscription logic for the observable sequence. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Creates an observable sequence object from the specified subscription function. + + Subscribe method implementation. + is null. + + + + Calls the subscription function that was supplied to the constructor. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Class to create an IObserver<T> instance from delegate-based implementations of the On* methods. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObserver<T> interface. + + This base class enforces the grammar of observers where OnError and OnCompleted are terminal messages. + The type of the elements in the sequence. + + + + Creates a new observer in a non-stopped state. + + + + + Notifies the observer of a new element in the sequence. + + Next element in the sequence. + + + + Implement this method to react to the receival of a new element in the sequence. + + Next element in the sequence. + This method only gets called when the observer hasn't stopped yet. + + + + Notifies the observer that an exception has occurred. + + The error that has occurred. + is null. + + + + Implement this method to react to the occurrence of an exception. + + The error that has occurred. + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Notifies the observer of the end of the sequence. + + + + + Implement this method to react to the end of the sequence. + + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Disposes the observer, causing it to transition to the stopped state. + + + + + Core implementation of IDisposable. + + true if the Dispose call was triggered by the IDisposable.Dispose method; false if it was triggered by the finalizer. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + or or is null. + + + + Creates an observer from the specified OnNext action. + + Observer's OnNext action implementation. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + or is null. + + + + Calls the onNext action. + + Next element in the sequence. + + + + Calls the onError action. + + The error that has occurred. + + + + Calls the onCompleted action. + + + + + This class fuses logic from ObserverBase, AnonymousObserver, and SafeObserver into one class. When an observer + needs to be safeguarded, an instance of this type can be created by SafeObserver.Create when it detects its + input is an AnonymousObserver, which is commonly used by end users when using the Subscribe extension methods + that accept delegates for the On* handlers. By doing the fusion, we make the call stack depth shorter which + helps debugging and some performance. + + + + + Asynchronous lock. + + + + + Queues the action for execution. If the caller acquires the lock and becomes the owner, + the queue is processed. If the lock is already owned, the action is queued and will get + processed by the owner. + + Action to queue for execution. + is null. + + + + Clears the work items in the queue and drops further work being queued. + + + + + (Infrastructure) Concurrency abstraction layer. + + + + + Gets the current CAL. If no CAL has been set yet, it will be initialized to the default. + + + + + (Infrastructure) Concurrency abstraction layer interface. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Queues a method for execution at the specified relative time. + + Method to execute. + State to pass to the method. + Time to execute the method on. + Disposable object that can be used to stop the timer. + + + + Queues a method for periodic execution based on the specified period. + + Method to execute; should be safe for reentrancy. + Period for running the method periodically. + Disposable object that can be used to stop the timer. + + + + Queues a method for execution. + + Method to execute. + State to pass to the method. + Disposable object that can be used to cancel the queued method. + + + + Blocking sleep operation. + + Time to sleep. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Starts a new long-running thread. + + Method to execute. + State to pass to the method. + + + + Gets whether long-running scheduling is supported. + + + + + Provides a set of static properties to access commonly used schedulers. + + + + + Returns a scheduler that represents the original scheduler, without any of its interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable all optimizations for. + Proxy to the original scheduler but without any optimizations enabled. + is null. + + + + Returns a scheduler that represents the original scheduler, without the specified set of interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable the specified optimizations for. + Types of the optimization interfaces that have to be disabled. + Proxy to the original scheduler but without the specified optimizations enabled. + or is null. + + + + Returns a scheduler that wraps the original scheduler, adding exception handling for scheduled actions. + + Type of the exception to check for. + Scheduler to apply an exception filter for. + Handler that's run if an exception is caught. The exception will be rethrown if the handler returns false. + Wrapper around the original scheduler, enforcing exception handling. + or is null. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + The scheduler to run periodic work on. + 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). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + Scheduler to execute the action on. + State passed to the action to be executed. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + Scheduler to execute the action on. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Starts a new stopwatch object by dynamically discovering the scheduler's capabilities. + If the scheduler provides stopwatch functionality, the request will be forwarded to the stopwatch provider implementation. + Otherwise, the stopwatch will be emulated using the scheduler's notion of absolute time. + + Scheduler to obtain a stopwatch for. + New stopwatch object; started at the time of the request. + is null. + The resulting stopwatch object can have non-monotonic behavior. + + + + Returns the ISchedulerLongRunning implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the ISchedulerLongRunning implementation for. + The scheduler's ISchedulerLongRunning implementation if available; null otherwise. + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using in case a stopwatch is required, but use of emulation stopwatch based + on the scheduler's clock is acceptable. Use of this method is recommended for best-effort use of the stopwatch provider + scheduler service, where the caller falls back to not using stopwatches if this facility wasn't found. + + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using the Scheduler.SchedulePeriodic extension methods for IScheduler in case periodic scheduling is required and + emulation of periodic behavior using other scheduler services is desirable. Use of this method is recommended for best-effort + use of the periodic scheduling service, where the caller falls back to not using periodic scheduling if this facility wasn't + found. + + + + + + Normalizes the specified TimeSpan value to a positive value. + + The TimeSpan value to normalize. + The specified TimeSpan value if it is zero or positive; otherwise, TimeSpan.Zero. + + + + Schedules an action to be executed recursively. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in recursive invocation state. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified relative time. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified absolute time. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed after the specified relative due time. + + Scheduler to execute the action on. + Action to execute. + Relative time after which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at the specified absolute due time. + + Scheduler to execute the action on. + Action to execute. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Gets the current time according to the local machine's system clock. + + + + + Gets a scheduler that schedules work immediately on the current thread. + + + + + Gets a scheduler that schedules work as soon as possible on the current thread. + + + + + Gets a scheduler that schedules work on the platform's default scheduler. + + + + + Gets a scheduler that schedules work on the thread pool. + + + + + Gets a scheduler that schedules work on a new thread using default thread creation options. + + + + + Gets a scheduler that schedules work on Task Parallel Library (TPL) task pool using the default TaskScheduler. + + + + + Abstract base class for machine-local schedulers, using the local system clock for time-based operations. + + + + + Maximum error ratio for timer drift. We've seen machines with 10s drift on a + daily basis, which is in the order 10E-4, so we allow for extra margin here. + This value is used to calculate early arrival for the long term queue timer + that will reevaluate work for the short term queue. + + Example: -------------------------------...---------------------*-----$ + ^ ^ + | | + early due + 0.999 1.0 + + We also make the gap between early and due at least LONGTOSHORT so we have + enough time to transition work to short term and as a courtesy to the + destination scheduler to manage its queues etc. + + + + + Gate to protect queues and to synchronize scheduling decisions and system clock + change management. + + + + + Long term work queue. Contains work that's due beyond SHORTTERM, computed at the + time of enqueueing. + + + + + Disposable resource for the long term timer that will reevaluate and dispatch the + first item in the long term queue. A serial disposable is used to make "dispose + current and assign new" logic easier. The disposable itself is never disposed. + + + + + Item at the head of the long term queue for which the current long term timer is + running. Used to detect changes in the queue and decide whether we should replace + or can continue using the current timer (because no earlier long term work was + added to the queue). + + + + + Short term work queue. Contains work that's due soon, computed at the time of + enqueueing or upon reevaluation of the long term queue causing migration of work + items. This queue is kept in order to be able to relocate short term items back + to the long term queue in case a system clock change occurs. + + + + + Set of disposable handles to all of the current short term work Schedule calls, + allowing those to be cancelled upon a system clock change. + + + + + Threshold where an item is considered to be short term work or gets moved from + long term to short term. + + + + + Minimum threshold for the long term timer to fire before the queue is reevaluated + for short term work. This value is chosen to be less than SHORTTERM in order to + ensure the timer fires and has work to transition to the short term queue. + + + + + Threshold used to determine when a short term timer has fired too early compared + to the absolute due time. This provides a last chance protection against early + completion of scheduled work, which can happen in case of time adjustment in the + operating system (cf. GetSystemTimeAdjustment). + + + + + Enqueues absolute time scheduled work in the timer queue or the short term work list. + + Scheduler to run the work on. Typically "this" from the caller's perspective (LocalScheduler.Schedule), but parameter kept because we have a single (static) timer queue across all of Rx local schedulers. + State to pass to the action. + Absolute time to run the work on. The timer queue is responsible to execute the work close to the specified time, also accounting for system clock changes. + Action to run, potentially recursing into the scheduler. + Disposable object to prevent the work from running. + + + + Schedule work that's due in the short term. This leads to relative scheduling calls to the + underlying scheduler for short TimeSpan values. If the system clock changes in the meantime, + the short term work is attempted to be cancelled and reevaluated. + + Work item to schedule in the short term. The caller is responsible to determine the work is indeed short term. + + + + Callback to process the next short term work item. + + Recursive scheduler supplied by the underlying scheduler. + Disposable used to identify the work the timer was triggered for (see code for usage). + Empty disposable. Recursive work cancellation is wired through the original WorkItem. + + + + Schedule work that's due on the long term. This leads to the work being queued up for + eventual transitioning to the short term work list. + + Work item to schedule on the long term. The caller is responsible to determine the work is indeed long term. + + + + Updates the long term timer which is responsible to transition work from the head of the + long term queue to the short term work list. + + Should be called under the scheduler lock. + + + + Evaluates the long term queue, transitioning short term work to the short term list, + and adjusting the new long term processing timer accordingly. + + Ignored. + + + + Callback invoked when a system clock change is observed in order to adjust and reevaluate + the internal scheduling queues. + + Currently not used. + Currently not used. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + Platform-specific scheduler implementations should reimplement IStopwatchProvider to provide a more + efficient IStopwatch implementation (if available). + + + + + Discovers scheduler services by interface type. The base class implementation returns + requested services for each scheduler interface implemented by the derived class. For + more control over service discovery, derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the scheduler's notion of current time. + + + + + Represents a work item in the absolute time scheduler. + + + This type is very similar to ScheduledItem, but we need a different Invoke signature to allow customization + of the target scheduler (e.g. when called in a recursive scheduling context, see ExecuteNextShortTermWorkItem). + + + + + Represents a work item that closes over scheduler invocation state. Subtyping is + used to have a common type for the scheduler queues. + + + + + Represents an object that schedules units of work on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the current thread scheduler. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Represents an object that schedules units of work to run immediately on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the immediate scheduler. + + + + + Abstract base class for scheduled work items. + + Absolute time representation type. + + + + Creates a new scheduled work item to run at the specified time. + + Absolute time at which the work item has to be executed. + Comparer used to compare work items based on their scheduled time. + is null. + + + + Invokes the work item. + + + + + Implement this method to perform the work item invocation, returning a disposable object for deep cancellation. + + Disposable object used to cancel the work item and/or derived work items. + + + + Compares the work item with another work item based on absolute time values. + + Work item to compare the current work item to. + Relative ordering between this and the specified work item. + The inequality operators are overloaded to provide results consistent with the IComparable implementation. Equality operators implement traditional reference equality semantics. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before or at the same of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after or at the same time of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are equal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are equal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are inequal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are inequal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether a ScheduledItem<TAbsolute> object is equal to the specified object. + + The object to compare to the current ScheduledItem<TAbsolute> object. + true if the obj parameter is a ScheduledItem<TAbsolute> object and is equal to the current ScheduledItem<TAbsolute> object; otherwise, false. + + + + Returns the hash code for the current ScheduledItem<TAbsolute> object. + + A 32-bit signed integer hash code. + + + + Cancels the work item by disposing the resource returned by InvokeCore as soon as possible. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Gets whether the work item has received a cancellation request. + + + + + Represents a scheduled work item based on the materialization of an IScheduler.Schedule method call. + + Absolute time representation type. + Type of the state passed to the scheduled action. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + Comparer used to compare work items based on their scheduled time. + or or is null. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + or is null. + + + + Invokes the scheduled action with the supplied recursive scheduler and state. + + Cancellation resource returned by the scheduled action. + + + + Efficient scheduler queue that maintains scheduled items sorted by absolute time. + + Absolute time representation type. + This type is not thread safe; users should ensure proper synchronization. + + + + Creates a new scheduler queue with a default initial capacity. + + + + + Creats a new scheduler queue with the specified initial capacity. + + Initial capacity of the scheduler queue. + is less than zero. + + + + Enqueues the specified work item to be scheduled. + + Work item to be scheduled. + + + + Removes the specified work item from the scheduler queue. + + Work item to be removed from the scheduler queue. + true if the item was found; false otherwise. + + + + Dequeues the next work item from the scheduler queue. + + Next work item in the scheduler queue (removed). + + + + Peeks the next work item in the scheduler queue. + + Next work item in the scheduler queue (not removed). + + + + Gets the number of scheduled items in the scheduler queue. + + + + + Provides basic synchronization and scheduling services for observable sequences. + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified scheduler. + In order to invoke observer callbacks on the specified scheduler, e.g. to offload callback processing to a dedicated thread, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified synchronization context. + In order to invoke observer callbacks on the specified synchronization context, e.g. to post callbacks to a UI thread represented by the synchronization context, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + + + Wraps the source sequence in order to ensure observer callbacks are properly serialized. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + + + Wraps the source sequence in order to ensure observer callbacks are synchronized using the specified gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Base class for implementation of query operators, providing performance benefits over the use of Observable.Create. + + Type of the resulting sequence's elements. + + + + Interface with variance annotation; allows for better type checking when detecting capabilities in SubscribeSafe. + + Type of the resulting sequence's elements. + + + + Publicly visible Subscribe method. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + IDisposable to cancel the subscription. This causes the underlying sink to be notified of unsubscription, causing it to prevent further messages from being sent to the observer. + + + + Core implementation of the query operator, called upon a new subscription to the producer object. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + The subscription disposable object returned from the Run call, passed in such that it can be forwarded to the sink, allowing it to dispose the subscription upon sending a final message (or prematurely for other reasons). + Callback to communicate the sink object to the subscriber, allowing consumers to tunnel a Dispose call into the sink, which can stop the processing. + Disposable representing all the resources and/or subscriptions the operator uses to process events. + The observer passed in to this method is not protected using auto-detach behavior upon an OnError or OnCompleted call. The implementation must ensure proper resource disposal and enforce the message grammar. + + + + Base class for implementation of query operators, providing a lightweight sink that can be disposed to mute the outgoing observer. + + Type of the resulting sequence's elements. + Implementations of sinks are responsible to enforce the message grammar on the associated observer. Upon sending a terminal message, a pairing Dispose call should be made to trigger cancellation of related resources and to mute the outgoing observer. + + + + Represents an object that schedules units of work on a provided . + + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + is null. + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + Configures whether scheduling always posts to the synchronization context, regardless whether the caller is on the same synchronization context. + is null. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Represents an object that schedules units of work on the platform's default scheduler. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a System.Threading.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. + + + + Schedules a periodic piece of work, using a System.Threading.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 less than TimeSpan.Zero. + is null. + + + + Discovers scheduler services by interface type. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the singleton instance of the default scheduler. + + + + + Represents an Action-based disposable. + + + + + Constructs a new disposable with the given action used for disposal. + + Disposal action which will be run upon calling Dispose. + + + + Calls the disposal action if and only if the current instance hasn't been disposed yet. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that can be checked for disposal status. + + + + + Initializes a new instance of the class. + + + + + Sets the status to disposed, which can be observer through the property. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that has an associated that will be set to the cancellation requested state upon disposal. + + + + + Initializes a new instance of the class that uses an existing . + + used for cancellation. + is null. + + + + Initializes a new instance of the class that uses a new . + + + + + Cancels the underlying . + + + + + Gets the used by this CancellationDisposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a group of disposable resources that are disposed together. + + + + + Initializes a new instance of the class with no disposables contained by it initially. + + + + + Initializes a new instance of the class with the specified number of disposables. + + The number of disposables that the new CompositeDisposable can initially store. + is less than zero. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed. + + Disposable to add. + is null. + + + + Removes and disposes the first occurrence of a disposable from the CompositeDisposable. + + Disposable to remove. + true if found; false otherwise. + is null. + + + + Disposes all disposables in the group and removes them from the group. + + + + + Removes and disposes all disposables from the CompositeDisposable, but does not dispose the CompositeDisposable. + + + + + Determines whether the CompositeDisposable contains a specific disposable. + + Disposable to search for. + true if the disposable was found; otherwise, false. + is null. + + + + Copies the disposables contained in the CompositeDisposable to an array, starting at a particular array index. + + Array to copy the contained disposables to. + Target index at which to copy the first disposable of the group. + is null. + is less than zero. -or - is larger than or equal to the array length. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Gets the number of disposables contained in the CompositeDisposable. + + + + + Always returns false. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be posted to the specified . + + + + + Initializes a new instance of the class that uses the specified on which to dispose the specified disposable resource. + + Context to perform disposal on. + Disposable whose Dispose operation to run on the given synchronization context. + or is null. + + + + Disposes the underlying disposable on the provided . + + + + + Gets the provided . + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable that does nothing on disposal. + + + + + Singleton default disposable. + + + + + Does nothing. + + + + + Provides a set of static methods for creating Disposables. + + + + + Creates a disposable object that invokes the specified action when disposed. + + Action to run during the first call to . The action is guaranteed to be run at most once. + The disposable object that runs the given action upon disposal. + is null. + + + + Gets the disposable that does nothing when disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be swapped for another disposable resource. + + + + + Initializes a new instance of the class with no current underlying disposable. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + If the MutableDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. + + + + Represents a disposable resource that only disposes its underlying disposable resource when all dependent disposable objects have been disposed. + + + + + Initializes a new instance of the class with the specified disposable. + + Underlying disposable. + is null. + + + + Returns a dependent disposable that when disposed decreases the refcount on the underlying disposable. + + A dependent disposable contributing to the reference count that manages the underlying disposable's lifetime. + + + + Disposes the underlying disposable only when all dependent disposables have been disposed. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be scheduled on the specified . + + + + + Initializes a new instance of the class that uses an on which to dispose the disposable. + + Scheduler where the disposable resource will be disposed on. + Disposable resource to dispose on the given scheduler. + or is null. + + + + Disposes the wrapped disposable on the provided scheduler. + + + + + Gets the scheduler where the disposable resource will be disposed on. + + + + + Gets the underlying disposable. After disposal, the result is undefined. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be replaced by another disposable resource, causing automatic disposal of the previous underlying disposable resource. + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. + + If the SerialDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. Assigning this property disposes the previous disposable object. + + + + Represents a disposable resource which only allows a single assignment of its underlying disposable resource. + If an underlying disposable resource has already been set, future attempts to set the underlying disposable resource will throw an . + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + Thrown if the SingleAssignmentDisposable has already been assigned to. + + + + (Infrastructure) Services to rethrow exceptions. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Rethrows the specified exception. + + Exception to rethrow. + + + + (Infrastructure) Provides access to the host's lifecycle management services. + + + + + Adds a reference to the host lifecycle manager, causing it to be sending notifications. + + + + + Removes a reference to the host lifecycle manager, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Event that gets raised when the host suspends the application. + + + + + Event that gets raised when the host resumes the application. + + + + + (Infrastructure) Provides notifications about the host's lifecycle events. + + + + + Event that gets raised when the host suspends. + + + + + Event that gets raised when the host resumes. + + + + + (Infrastructure) Event arguments for host suspension events. + + + + + (Infrastructure) Event arguments for host resumption events. + + + + + (Infrastructure) Interface for enlightenment providers. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Gets the current enlightenment provider. If none is loaded yet, accessing this property triggers provider resolution. + + + This member is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Provides access to local system clock services. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Adds a reference to the system clock monitor, causing it to be sending notifications. + + Thrown when the system doesn't support sending clock change notifications. + + + + Removes a reference to the system clock monitor, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Gets the local system clock time. + + + + + Event that gets raised when a system clock change is detected, if there's any interest as indicated by AddRef calls. + + + + + (Infrastructure) Provides access to the local system clock. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Gets the current time. + + + + + (Infrastructure) Provides a mechanism to notify local schedulers about system clock changes. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Event that gets raised when a system clock change is detected. + + + + + (Infrastructure) Event arguments for system clock change notifications. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Creates a new system clock notification object with unknown old and new times. + + + + + Creates a new system clock notification object with the specified old and new times. + + Time before the system clock changed, or DateTimeOffset.MinValue if not known. + Time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + Gets the time before the system clock changed, or DateTimeOffset.MinValue if not known. + + + + + Gets the time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + + (Infrastructure) Provides access to the local system clock. + + + + + Gets the current time. + + + + + (Infrastructure) Monitors for system clock changes based on a periodic timer. + + + + + Creates a new monitor for system clock changes with the specified polling frequency. + + Polling frequency for system clock changes. + + + + Event that gets raised when a system clock change is detected. + + + + + Indicates the type of a notification. + + + + + Represents an OnNext notification. + + + + + Represents an OnError notification. + + + + + Represents an OnCompleted notification. + + + + + Represents a notification to an observer. + + The type of the elements received by the observer. + + + + Default constructor used by derived types. + + + + + Determines whether the current Notification<T> object has the same observer message payload as a specified Notification<T> value. + + An object to compare to the current Notification<T> object. + true if both Notification<T> objects have the same observer message payload; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have the same observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has the same observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have a different observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has a different observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent a different observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the specified System.Object is equal to the current Notification<T>. + + The System.Object to compare with the current Notification<T>. + true if the specified System.Object is equal to the current Notification<T>; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + The type of the result returned from the observer's notification handlers. + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + The type of the result returned from the notification handler delegates. + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns an observable sequence with a single notification, using the immediate scheduler. + + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns an observable sequence with a single notification. + + Scheduler to send out the notification calls on. + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns the value of an OnNext notification or throws an exception. + + + + + Returns a value that indicates whether the notification has a value. + + + + + Returns the exception of an OnError notification or returns null. + + + + + Gets the kind of notification that is represented. + + + + + Represents an OnNext notification to an observer. + + + + + Constructs a notification of a new value. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and a specified object are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns the value of an OnNext notification. + + + + + Returns null. + + + + + Returns true. + + + + + Returns NotificationKind.OnNext. + + + + + Represents an OnError notification to an observer. + + + + + Constructs a notification of an exception. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws the exception. + + + + + Returns the exception. + + + + + Returns false. + + + + + Returns NotificationKind.OnError. + + + + + Represents an OnCompleted notification to an observer. + + + + + Constructs a notification of the end of a sequence. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws an InvalidOperationException. + + + + + Returns null. + + + + + Returns false. + + + + + Returns NotificationKind.OnCompleted. + + + + + Provides a set of static methods for constructing notifications. + + + + + Creates an object that represents an OnNext notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The value contained in the notification. + The OnNext notification containing the value. + + + + Creates an object that represents an OnError notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The exception contained in the notification. + The OnError notification containing the exception. + is null. + + + + Creates an object that represents an OnCompleted notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The OnCompleted notification. + + + + Represents a type with a single value. This type is often used to denote the successful completion of a void-returning method (C#) or a Sub procedure (Visual Basic). + + + + + Determines whether the specified Unit values is equal to the current Unit. Because Unit has a single value, this always returns true. + + An object to compare to the current Unit value. + Because Unit has a single value, this always returns true. + + + + Determines whether the specified System.Object is equal to the current Unit. + + The System.Object to compare with the current Unit. + true if the specified System.Object is a Unit value; otherwise, false. + + + + Returns the hash code for the current Unit value. + + A hash code for the current Unit value. + + + + Returns a string representation of the current Unit value. + + String representation of the current Unit value. + + + + Determines whether the two specified Unit values are equal. Because Unit has a single value, this always returns true. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns true. + + + + Determines whether the two specified Unit values are not equal. Because Unit has a single value, this always returns false. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns false. + + + + Gets the single unit value. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + 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.. + + + + + Looks up a localized string similar to OnCompleted notification doesn't have a value.. + + + + + Looks up a localized string similar to Disposable has already been assigned.. + + + + + Looks up a localized string similar to Failed to start monitoring system clock changes.. + + + + + Looks up a localized string similar to Heap is empty.. + + + + + Looks up a localized string similar to Reentrancy has been detected.. + + + + + Looks up a localized string similar to Observer has already terminated.. + + + + + Looks up a localized string similar to This scheduler operation has already been awaited.. + + + + diff --git a/packages/Rx-Core.2.1.30214.0/lib/Net40/System.Reactive.Core.dll b/packages/Rx-Core.2.1.30214.0/lib/Net40/System.Reactive.Core.dll new file mode 100644 index 0000000000000000000000000000000000000000..1a7ae924082d59eab433e0b303c8651b21c43a9a GIT binary patch literal 104008 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 z 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 + + + System.Reactive.Core + + + + + The System.Reactive.PlatformServices namespace contains interfaces and classes used by the runtime infrastructure of Reactive Extensions. + Those are not intended to be used directly from user code and are subject to change in future releases of the product. + + + + + Provides a set of static methods for subscribing delegates to observables. + + + + + Subscribes to the observable sequence without specifying any handlers. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + IDisposable object used to unsubscribe from the observable sequence. + is null. + + + + Subscribes an element handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or or is null. + + + + Subscribes an observer to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer to subscribe to the sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or is null. + + + + Subscribes to the observable sequence without specifying any handlers, using a CancellationToken to support unsubscription. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + CancellationToken that can be signaled to unsubscribe from the source sequence. + is null. + + + + Subscribes an element handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or or is null. + + + + Subscribes to the specified source, re-routing synchronous exceptions during invocation of the Subscribe method to the observer's OnError channel. + This method is typically used when writing query operators. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer that will be passed to the observable sequence, and that will be used for exception propagation. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Provides a set of static methods for creating observers. + + + + + Creates an observer from a notification callback. + + The type of the elements received by the observer. + Action that handles a notification. + The observer object that invokes the specified handler using a notification corresponding to each message it receives. + is null. + + + + Creates a notification callback from an observer. + + The type of the elements received by the observer. + Observer object. + The action that forwards its input notification to the underlying observer. + is null. + + + + Creates an observer from the specified OnNext action. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + The observer object implemented using the given actions. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or or is null. + + + + Hides the identity of an observer. + + The type of the elements received by the source observer. + An observer whose identity to hide. + An observer that hides the identity of the specified observer. + is null. + + + + Checks access to the observer for grammar violations. This includes checking for multiple OnError or OnCompleted calls, as well as reentrancy in any of the observer methods. + If a violation is detected, an InvalidOperationException is thrown from the offending observer method call. + + The type of the elements received by the source observer. + The observer whose callback invocations should be checked for grammar violations. + An observer that checks callbacks invocations against the observer grammar and, if the checks pass, forwards those to the specified observer. + is null. + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently from multiple threads. This overload is useful when coordinating access to an observer. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload, passing true for the second parameter. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently. This overload is useful when coordinating access to an observer. + The parameter configures the type of lock used for synchronization. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + If set to true, reentrant observer callbacks will be queued up and get delivered to the observer in a sequential manner. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + When the parameter is set to false, behavior is identical to the overload which uses + a Monitor for synchronization. When the parameter is set to true, an + is used to queue up callbacks to the specified observer if a reentrant call is made. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently by multiple threads, using the specified gate object for use by a Monitor-based lock. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common gate object. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently, using the specified asynchronous lock to protect against concurrent and reentrant access. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common asynchronous lock. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + + + Schedules the invocation of observer methods on the given scheduler. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Scheduler to schedule observer messages on. + Observer whose messages are scheduled on the given scheduler. + or is null. + + + + Schedules the invocation of observer methods on the given synchonization context. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Synchonization context to schedule observer messages on. + Observer whose messages are scheduled on the given synchonization context. + or is null. + + + + Converts an observer to a progress object. + + The type of the progress objects received by the source observer. + The observer to convert. + Progress object whose Report messages correspond to the observer's OnNext messages. + is null. + + + + Converts an observer to a progress object, using the specified scheduler to invoke the progress reporting method. + + The type of the progress objects received by the source observer. + The observer to convert. + Scheduler to report progress on. + Progress object whose Report messages correspond to the observer's OnNext messages. + or is null. + + + + Converts a progress object to an observer. + + The type of the progress objects received by the progress reporter. + The progress object to convert. + Observer whose OnNext messages correspond to the progress object's Report messages. + is null. + + + + Class to create an IObservable<T> instance from a delegate-based implementation of the Subscribe method. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObservable<T> interface. + + + If you don't need a named type to create an observable sequence (i.e. you rather need + an instance rather than a reusable type), use the Observable.Create method to create + an observable sequence with specified subscription behavior. + + The type of the elements in the sequence. + + + + Subscribes the given observer to the observable sequence. + + Observer that will receive notifications from the observable sequence. + Disposable object representing an observer's subscription to the observable sequence. + is null. + + + + Implement this method with the core subscription logic for the observable sequence. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Creates an observable sequence object from the specified subscription function. + + Subscribe method implementation. + is null. + + + + Calls the subscription function that was supplied to the constructor. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Class to create an IObserver<T> instance from delegate-based implementations of the On* methods. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObserver<T> interface. + + This base class enforces the grammar of observers where OnError and OnCompleted are terminal messages. + The type of the elements in the sequence. + + + + Creates a new observer in a non-stopped state. + + + + + Notifies the observer of a new element in the sequence. + + Next element in the sequence. + + + + Implement this method to react to the receival of a new element in the sequence. + + Next element in the sequence. + This method only gets called when the observer hasn't stopped yet. + + + + Notifies the observer that an exception has occurred. + + The error that has occurred. + is null. + + + + Implement this method to react to the occurrence of an exception. + + The error that has occurred. + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Notifies the observer of the end of the sequence. + + + + + Implement this method to react to the end of the sequence. + + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Disposes the observer, causing it to transition to the stopped state. + + + + + Core implementation of IDisposable. + + true if the Dispose call was triggered by the IDisposable.Dispose method; false if it was triggered by the finalizer. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + or or is null. + + + + Creates an observer from the specified OnNext action. + + Observer's OnNext action implementation. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + or is null. + + + + Calls the onNext action. + + Next element in the sequence. + + + + Calls the onError action. + + The error that has occurred. + + + + Calls the onCompleted action. + + + + + This class fuses logic from ObserverBase, AnonymousObserver, and SafeObserver into one class. When an observer + needs to be safeguarded, an instance of this type can be created by SafeObserver.Create when it detects its + input is an AnonymousObserver, which is commonly used by end users when using the Subscribe extension methods + that accept delegates for the On* handlers. By doing the fusion, we make the call stack depth shorter which + helps debugging and some performance. + + + + + Asynchronous lock. + + + + + Queues the action for execution. If the caller acquires the lock and becomes the owner, + the queue is processed. If the lock is already owned, the action is queued and will get + processed by the owner. + + Action to queue for execution. + is null. + + + + Clears the work items in the queue and drops further work being queued. + + + + + (Infrastructure) Concurrency abstraction layer. + + + + + Gets the current CAL. If no CAL has been set yet, it will be initialized to the default. + + + + + (Infrastructure) Concurrency abstraction layer interface. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Queues a method for execution at the specified relative time. + + Method to execute. + State to pass to the method. + Time to execute the method on. + Disposable object that can be used to stop the timer. + + + + Queues a method for periodic execution based on the specified period. + + Method to execute; should be safe for reentrancy. + Period for running the method periodically. + Disposable object that can be used to stop the timer. + + + + Queues a method for execution. + + Method to execute. + State to pass to the method. + Disposable object that can be used to cancel the queued method. + + + + Blocking sleep operation. + + Time to sleep. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Starts a new long-running thread. + + Method to execute. + State to pass to the method. + + + + Gets whether long-running scheduling is supported. + + + + + Provides a set of static properties to access commonly used schedulers. + + + + + Returns a scheduler that represents the original scheduler, without any of its interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable all optimizations for. + Proxy to the original scheduler but without any optimizations enabled. + is null. + + + + Returns a scheduler that represents the original scheduler, without the specified set of interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable the specified optimizations for. + Types of the optimization interfaces that have to be disabled. + Proxy to the original scheduler but without the specified optimizations enabled. + or is null. + + + + Returns a scheduler that wraps the original scheduler, adding exception handling for scheduled actions. + + Type of the exception to check for. + Scheduler to apply an exception filter for. + Handler that's run if an exception is caught. The exception will be rethrown if the handler returns false. + Wrapper around the original scheduler, enforcing exception handling. + or is null. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + The scheduler to run periodic work on. + 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). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + Scheduler to execute the action on. + State passed to the action to be executed. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + Scheduler to execute the action on. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Starts a new stopwatch object by dynamically discovering the scheduler's capabilities. + If the scheduler provides stopwatch functionality, the request will be forwarded to the stopwatch provider implementation. + Otherwise, the stopwatch will be emulated using the scheduler's notion of absolute time. + + Scheduler to obtain a stopwatch for. + New stopwatch object; started at the time of the request. + is null. + The resulting stopwatch object can have non-monotonic behavior. + + + + Returns the ISchedulerLongRunning implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the ISchedulerLongRunning implementation for. + The scheduler's ISchedulerLongRunning implementation if available; null otherwise. + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using in case a stopwatch is required, but use of emulation stopwatch based + on the scheduler's clock is acceptable. Use of this method is recommended for best-effort use of the stopwatch provider + scheduler service, where the caller falls back to not using stopwatches if this facility wasn't found. + + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using the Scheduler.SchedulePeriodic extension methods for IScheduler in case periodic scheduling is required and + emulation of periodic behavior using other scheduler services is desirable. Use of this method is recommended for best-effort + use of the periodic scheduling service, where the caller falls back to not using periodic scheduling if this facility wasn't + found. + + + + + + Yields execution of the current work item on the scheduler to another work item on the scheduler. + The caller should await the result of calling Yield to schedule the remainder of the current work item (known as the continuation). + + Scheduler to yield work on. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Yields execution of the current work item on the scheduler to another work item on the scheduler. + The caller should await the result of calling Yield to schedule the remainder of the current work item (known as the continuation). + + Scheduler to yield work on. + Cancellation token to cancel the continuation to run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler for the specified duration. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) after the specified duration. + + Scheduler to yield work on. + Time when the continuation should run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler for the specified duration. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) after the specified duration. + + Scheduler to yield work on. + Time when the continuation should run. + Cancellation token to cancel the continuation to run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler until the specified due time. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) at the specified due time. + + Scheduler to yield work on. + Time when the continuation should run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler until the specified due time. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) at the specified due time. + + Scheduler to yield work on. + Time when the continuation should run. + Cancellation token to cancel the continuation to run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Normalizes the specified TimeSpan value to a positive value. + + The TimeSpan value to normalize. + The specified TimeSpan value if it is zero or positive; otherwise, TimeSpan.Zero. + + + + Schedules an action to be executed recursively. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in recursive invocation state. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified relative time. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified absolute time. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed after the specified relative due time. + + Scheduler to execute the action on. + Action to execute. + Relative time after which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at the specified absolute due time. + + Scheduler to execute the action on. + Action to execute. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Gets the current time according to the local machine's system clock. + + + + + Gets a scheduler that schedules work immediately on the current thread. + + + + + Gets a scheduler that schedules work as soon as possible on the current thread. + + + + + Gets a scheduler that schedules work on the platform's default scheduler. + + + + + Gets a scheduler that schedules work on the thread pool. + + + + + Gets a scheduler that schedules work on a new thread using default thread creation options. + + + + + Gets a scheduler that schedules work on Task Parallel Library (TPL) task pool using the default TaskScheduler. + + + + + Abstract base class for machine-local schedulers, using the local system clock for time-based operations. + + + + + Maximum error ratio for timer drift. We've seen machines with 10s drift on a + daily basis, which is in the order 10E-4, so we allow for extra margin here. + This value is used to calculate early arrival for the long term queue timer + that will reevaluate work for the short term queue. + + Example: -------------------------------...---------------------*-----$ + ^ ^ + | | + early due + 0.999 1.0 + + We also make the gap between early and due at least LONGTOSHORT so we have + enough time to transition work to short term and as a courtesy to the + destination scheduler to manage its queues etc. + + + + + Gate to protect queues and to synchronize scheduling decisions and system clock + change management. + + + + + Long term work queue. Contains work that's due beyond SHORTTERM, computed at the + time of enqueueing. + + + + + Disposable resource for the long term timer that will reevaluate and dispatch the + first item in the long term queue. A serial disposable is used to make "dispose + current and assign new" logic easier. The disposable itself is never disposed. + + + + + Item at the head of the long term queue for which the current long term timer is + running. Used to detect changes in the queue and decide whether we should replace + or can continue using the current timer (because no earlier long term work was + added to the queue). + + + + + Short term work queue. Contains work that's due soon, computed at the time of + enqueueing or upon reevaluation of the long term queue causing migration of work + items. This queue is kept in order to be able to relocate short term items back + to the long term queue in case a system clock change occurs. + + + + + Set of disposable handles to all of the current short term work Schedule calls, + allowing those to be cancelled upon a system clock change. + + + + + Threshold where an item is considered to be short term work or gets moved from + long term to short term. + + + + + Minimum threshold for the long term timer to fire before the queue is reevaluated + for short term work. This value is chosen to be less than SHORTTERM in order to + ensure the timer fires and has work to transition to the short term queue. + + + + + Threshold used to determine when a short term timer has fired too early compared + to the absolute due time. This provides a last chance protection against early + completion of scheduled work, which can happen in case of time adjustment in the + operating system (cf. GetSystemTimeAdjustment). + + + + + Enqueues absolute time scheduled work in the timer queue or the short term work list. + + Scheduler to run the work on. Typically "this" from the caller's perspective (LocalScheduler.Schedule), but parameter kept because we have a single (static) timer queue across all of Rx local schedulers. + State to pass to the action. + Absolute time to run the work on. The timer queue is responsible to execute the work close to the specified time, also accounting for system clock changes. + Action to run, potentially recursing into the scheduler. + Disposable object to prevent the work from running. + + + + Schedule work that's due in the short term. This leads to relative scheduling calls to the + underlying scheduler for short TimeSpan values. If the system clock changes in the meantime, + the short term work is attempted to be cancelled and reevaluated. + + Work item to schedule in the short term. The caller is responsible to determine the work is indeed short term. + + + + Callback to process the next short term work item. + + Recursive scheduler supplied by the underlying scheduler. + Disposable used to identify the work the timer was triggered for (see code for usage). + Empty disposable. Recursive work cancellation is wired through the original WorkItem. + + + + Schedule work that's due on the long term. This leads to the work being queued up for + eventual transitioning to the short term work list. + + Work item to schedule on the long term. The caller is responsible to determine the work is indeed long term. + + + + Updates the long term timer which is responsible to transition work from the head of the + long term queue to the short term work list. + + Should be called under the scheduler lock. + + + + Evaluates the long term queue, transitioning short term work to the short term list, + and adjusting the new long term processing timer accordingly. + + Ignored. + + + + Callback invoked when a system clock change is observed in order to adjust and reevaluate + the internal scheduling queues. + + Currently not used. + Currently not used. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + Platform-specific scheduler implementations should reimplement IStopwatchProvider to provide a more + efficient IStopwatch implementation (if available). + + + + + Discovers scheduler services by interface type. The base class implementation returns + requested services for each scheduler interface implemented by the derived class. For + more control over service discovery, derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the scheduler's notion of current time. + + + + + Represents a work item in the absolute time scheduler. + + + This type is very similar to ScheduledItem, but we need a different Invoke signature to allow customization + of the target scheduler (e.g. when called in a recursive scheduling context, see ExecuteNextShortTermWorkItem). + + + + + Represents a work item that closes over scheduler invocation state. Subtyping is + used to have a common type for the scheduler queues. + + + + + Represents an object that schedules units of work on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the current thread scheduler. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Represents an object that schedules units of work to run immediately on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the immediate scheduler. + + + + + Abstract base class for scheduled work items. + + Absolute time representation type. + + + + Creates a new scheduled work item to run at the specified time. + + Absolute time at which the work item has to be executed. + Comparer used to compare work items based on their scheduled time. + is null. + + + + Invokes the work item. + + + + + Implement this method to perform the work item invocation, returning a disposable object for deep cancellation. + + Disposable object used to cancel the work item and/or derived work items. + + + + Compares the work item with another work item based on absolute time values. + + Work item to compare the current work item to. + Relative ordering between this and the specified work item. + The inequality operators are overloaded to provide results consistent with the IComparable implementation. Equality operators implement traditional reference equality semantics. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before or at the same of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after or at the same time of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are equal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are equal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are inequal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are inequal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether a ScheduledItem<TAbsolute> object is equal to the specified object. + + The object to compare to the current ScheduledItem<TAbsolute> object. + true if the obj parameter is a ScheduledItem<TAbsolute> object and is equal to the current ScheduledItem<TAbsolute> object; otherwise, false. + + + + Returns the hash code for the current ScheduledItem<TAbsolute> object. + + A 32-bit signed integer hash code. + + + + Cancels the work item by disposing the resource returned by InvokeCore as soon as possible. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Gets whether the work item has received a cancellation request. + + + + + Represents a scheduled work item based on the materialization of an IScheduler.Schedule method call. + + Absolute time representation type. + Type of the state passed to the scheduled action. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + Comparer used to compare work items based on their scheduled time. + or or is null. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + or is null. + + + + Invokes the scheduled action with the supplied recursive scheduler and state. + + Cancellation resource returned by the scheduled action. + + + + Represents an awaitable scheduler operation. Awaiting the object causes the continuation to be posted back to the originating scheduler's work queue. + + + + + Controls whether the continuation is run on the originating synchronization context (false by default). + + true to run the continuation on the captured synchronization context; false otherwise (default). + Scheduler operation object with configured await behavior. + + + + Gets an awaiter for the scheduler operation, used to post back the continuation. + + Awaiter for the scheduler operation. + + + + (Infrastructure) Scheduler operation awaiter type used by the code generated for C# await and Visual Basic Await expressions. + + + + + Completes the scheduler operation, throwing an OperationCanceledException in case cancellation was requested. + + + + + Registers the continuation with the scheduler operation. + + Continuation to be run on the originating scheduler. + + + + Indicates whether the scheduler operation has completed. Returns false unless cancellation was already requested. + + + + + Efficient scheduler queue that maintains scheduled items sorted by absolute time. + + Absolute time representation type. + This type is not thread safe; users should ensure proper synchronization. + + + + Creates a new scheduler queue with a default initial capacity. + + + + + Creats a new scheduler queue with the specified initial capacity. + + Initial capacity of the scheduler queue. + is less than zero. + + + + Enqueues the specified work item to be scheduled. + + Work item to be scheduled. + + + + Removes the specified work item from the scheduler queue. + + Work item to be removed from the scheduler queue. + true if the item was found; false otherwise. + + + + Dequeues the next work item from the scheduler queue. + + Next work item in the scheduler queue (removed). + + + + Peeks the next work item in the scheduler queue. + + Next work item in the scheduler queue (not removed). + + + + Gets the number of scheduled items in the scheduler queue. + + + + + Provides basic synchronization and scheduling services for observable sequences. + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified scheduler. + In order to invoke observer callbacks on the specified scheduler, e.g. to offload callback processing to a dedicated thread, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified synchronization context. + In order to invoke observer callbacks on the specified synchronization context, e.g. to post callbacks to a UI thread represented by the synchronization context, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + + + Wraps the source sequence in order to ensure observer callbacks are properly serialized. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + + + Wraps the source sequence in order to ensure observer callbacks are synchronized using the specified gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Base class for implementation of query operators, providing performance benefits over the use of Observable.Create. + + Type of the resulting sequence's elements. + + + + Interface with variance annotation; allows for better type checking when detecting capabilities in SubscribeSafe. + + Type of the resulting sequence's elements. + + + + Publicly visible Subscribe method. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + IDisposable to cancel the subscription. This causes the underlying sink to be notified of unsubscription, causing it to prevent further messages from being sent to the observer. + + + + Core implementation of the query operator, called upon a new subscription to the producer object. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + The subscription disposable object returned from the Run call, passed in such that it can be forwarded to the sink, allowing it to dispose the subscription upon sending a final message (or prematurely for other reasons). + Callback to communicate the sink object to the subscriber, allowing consumers to tunnel a Dispose call into the sink, which can stop the processing. + Disposable representing all the resources and/or subscriptions the operator uses to process events. + The observer passed in to this method is not protected using auto-detach behavior upon an OnError or OnCompleted call. The implementation must ensure proper resource disposal and enforce the message grammar. + + + + Base class for implementation of query operators, providing a lightweight sink that can be disposed to mute the outgoing observer. + + Type of the resulting sequence's elements. + Implementations of sinks are responsible to enforce the message grammar on the associated observer. Upon sending a terminal message, a pairing Dispose call should be made to trigger cancellation of related resources and to mute the outgoing observer. + + + + Represents an object that schedules units of work on a provided . + + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + is null. + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + Configures whether scheduling always posts to the synchronization context, regardless whether the caller is on the same synchronization context. + is null. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Represents an object that schedules units of work on the platform's default scheduler. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a System.Threading.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. + + + + Schedules a periodic piece of work, using a System.Threading.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 less than TimeSpan.Zero. + is null. + + + + Discovers scheduler services by interface type. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the singleton instance of the default scheduler. + + + + + Represents an Action-based disposable. + + + + + Constructs a new disposable with the given action used for disposal. + + Disposal action which will be run upon calling Dispose. + + + + Calls the disposal action if and only if the current instance hasn't been disposed yet. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that can be checked for disposal status. + + + + + Initializes a new instance of the class. + + + + + Sets the status to disposed, which can be observer through the property. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that has an associated that will be set to the cancellation requested state upon disposal. + + + + + Initializes a new instance of the class that uses an existing . + + used for cancellation. + is null. + + + + Initializes a new instance of the class that uses a new . + + + + + Cancels the underlying . + + + + + Gets the used by this CancellationDisposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a group of disposable resources that are disposed together. + + + + + Initializes a new instance of the class with no disposables contained by it initially. + + + + + Initializes a new instance of the class with the specified number of disposables. + + The number of disposables that the new CompositeDisposable can initially store. + is less than zero. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed. + + Disposable to add. + is null. + + + + Removes and disposes the first occurrence of a disposable from the CompositeDisposable. + + Disposable to remove. + true if found; false otherwise. + is null. + + + + Disposes all disposables in the group and removes them from the group. + + + + + Removes and disposes all disposables from the CompositeDisposable, but does not dispose the CompositeDisposable. + + + + + Determines whether the CompositeDisposable contains a specific disposable. + + Disposable to search for. + true if the disposable was found; otherwise, false. + is null. + + + + Copies the disposables contained in the CompositeDisposable to an array, starting at a particular array index. + + Array to copy the contained disposables to. + Target index at which to copy the first disposable of the group. + is null. + is less than zero. -or - is larger than or equal to the array length. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Gets the number of disposables contained in the CompositeDisposable. + + + + + Always returns false. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be posted to the specified . + + + + + Initializes a new instance of the class that uses the specified on which to dispose the specified disposable resource. + + Context to perform disposal on. + Disposable whose Dispose operation to run on the given synchronization context. + or is null. + + + + Disposes the underlying disposable on the provided . + + + + + Gets the provided . + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable that does nothing on disposal. + + + + + Singleton default disposable. + + + + + Does nothing. + + + + + Provides a set of static methods for creating Disposables. + + + + + Creates a disposable object that invokes the specified action when disposed. + + Action to run during the first call to . The action is guaranteed to be run at most once. + The disposable object that runs the given action upon disposal. + is null. + + + + Gets the disposable that does nothing when disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be swapped for another disposable resource. + + + + + Initializes a new instance of the class with no current underlying disposable. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + If the MutableDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. + + + + Represents a disposable resource that only disposes its underlying disposable resource when all dependent disposable objects have been disposed. + + + + + Initializes a new instance of the class with the specified disposable. + + Underlying disposable. + is null. + + + + Returns a dependent disposable that when disposed decreases the refcount on the underlying disposable. + + A dependent disposable contributing to the reference count that manages the underlying disposable's lifetime. + + + + Disposes the underlying disposable only when all dependent disposables have been disposed. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be scheduled on the specified . + + + + + Initializes a new instance of the class that uses an on which to dispose the disposable. + + Scheduler where the disposable resource will be disposed on. + Disposable resource to dispose on the given scheduler. + or is null. + + + + Disposes the wrapped disposable on the provided scheduler. + + + + + Gets the scheduler where the disposable resource will be disposed on. + + + + + Gets the underlying disposable. After disposal, the result is undefined. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be replaced by another disposable resource, causing automatic disposal of the previous underlying disposable resource. + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. + + If the SerialDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. Assigning this property disposes the previous disposable object. + + + + Represents a disposable resource which only allows a single assignment of its underlying disposable resource. + If an underlying disposable resource has already been set, future attempts to set the underlying disposable resource will throw an . + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + Thrown if the SingleAssignmentDisposable has already been assigned to. + + + + (Infrastructure) Services to rethrow exceptions. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Rethrows the specified exception. + + Exception to rethrow. + + + + (Infrastructure) Provides access to the host's lifecycle management services. + + + + + Adds a reference to the host lifecycle manager, causing it to be sending notifications. + + + + + Removes a reference to the host lifecycle manager, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Event that gets raised when the host suspends the application. + + + + + Event that gets raised when the host resumes the application. + + + + + (Infrastructure) Provides notifications about the host's lifecycle events. + + + + + Event that gets raised when the host suspends. + + + + + Event that gets raised when the host resumes. + + + + + (Infrastructure) Event arguments for host suspension events. + + + + + (Infrastructure) Event arguments for host resumption events. + + + + + (Infrastructure) Interface for enlightenment providers. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Gets the current enlightenment provider. If none is loaded yet, accessing this property triggers provider resolution. + + + This member is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Provides access to local system clock services. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Adds a reference to the system clock monitor, causing it to be sending notifications. + + Thrown when the system doesn't support sending clock change notifications. + + + + Removes a reference to the system clock monitor, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Gets the local system clock time. + + + + + Event that gets raised when a system clock change is detected, if there's any interest as indicated by AddRef calls. + + + + + (Infrastructure) Provides access to the local system clock. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Gets the current time. + + + + + (Infrastructure) Provides a mechanism to notify local schedulers about system clock changes. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Event that gets raised when a system clock change is detected. + + + + + (Infrastructure) Event arguments for system clock change notifications. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Creates a new system clock notification object with unknown old and new times. + + + + + Creates a new system clock notification object with the specified old and new times. + + Time before the system clock changed, or DateTimeOffset.MinValue if not known. + Time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + Gets the time before the system clock changed, or DateTimeOffset.MinValue if not known. + + + + + Gets the time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + + (Infrastructure) Provides access to the local system clock. + + + + + Gets the current time. + + + + + (Infrastructure) Monitors for system clock changes based on a periodic timer. + + + + + Creates a new monitor for system clock changes with the specified polling frequency. + + Polling frequency for system clock changes. + + + + Event that gets raised when a system clock change is detected. + + + + + Indicates the type of a notification. + + + + + Represents an OnNext notification. + + + + + Represents an OnError notification. + + + + + Represents an OnCompleted notification. + + + + + Represents a notification to an observer. + + The type of the elements received by the observer. + + + + Default constructor used by derived types. + + + + + Determines whether the current Notification<T> object has the same observer message payload as a specified Notification<T> value. + + An object to compare to the current Notification<T> object. + true if both Notification<T> objects have the same observer message payload; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have the same observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has the same observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have a different observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has a different observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent a different observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the specified System.Object is equal to the current Notification<T>. + + The System.Object to compare with the current Notification<T>. + true if the specified System.Object is equal to the current Notification<T>; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + The type of the result returned from the observer's notification handlers. + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + The type of the result returned from the notification handler delegates. + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns an observable sequence with a single notification, using the immediate scheduler. + + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns an observable sequence with a single notification. + + Scheduler to send out the notification calls on. + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns the value of an OnNext notification or throws an exception. + + + + + Returns a value that indicates whether the notification has a value. + + + + + Returns the exception of an OnError notification or returns null. + + + + + Gets the kind of notification that is represented. + + + + + Represents an OnNext notification to an observer. + + + + + Constructs a notification of a new value. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and a specified object are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns the value of an OnNext notification. + + + + + Returns null. + + + + + Returns true. + + + + + Returns NotificationKind.OnNext. + + + + + Represents an OnError notification to an observer. + + + + + Constructs a notification of an exception. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws the exception. + + + + + Returns the exception. + + + + + Returns false. + + + + + Returns NotificationKind.OnError. + + + + + Represents an OnCompleted notification to an observer. + + + + + Constructs a notification of the end of a sequence. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws an InvalidOperationException. + + + + + Returns null. + + + + + Returns false. + + + + + Returns NotificationKind.OnCompleted. + + + + + Provides a set of static methods for constructing notifications. + + + + + Creates an object that represents an OnNext notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The value contained in the notification. + The OnNext notification containing the value. + + + + Creates an object that represents an OnError notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The exception contained in the notification. + The OnError notification containing the exception. + is null. + + + + Creates an object that represents an OnCompleted notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The OnCompleted notification. + + + + Represents a type with a single value. This type is often used to denote the successful completion of a void-returning method (C#) or a Sub procedure (Visual Basic). + + + + + Determines whether the specified Unit values is equal to the current Unit. Because Unit has a single value, this always returns true. + + An object to compare to the current Unit value. + Because Unit has a single value, this always returns true. + + + + Determines whether the specified System.Object is equal to the current Unit. + + The System.Object to compare with the current Unit. + true if the specified System.Object is a Unit value; otherwise, false. + + + + Returns the hash code for the current Unit value. + + A hash code for the current Unit value. + + + + Returns a string representation of the current Unit value. + + String representation of the current Unit value. + + + + Determines whether the two specified Unit values are equal. Because Unit has a single value, this always returns true. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns true. + + + + Determines whether the two specified Unit values are not equal. Because Unit has a single value, this always returns false. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns false. + + + + Gets the single unit value. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + 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.. + + + + + Looks up a localized string similar to OnCompleted notification doesn't have a value.. + + + + + Looks up a localized string similar to Disposable has already been assigned.. + + + + + Looks up a localized string similar to Failed to start monitoring system clock changes.. + + + + + Looks up a localized string similar to Heap is empty.. + + + + + Looks up a localized string similar to Reentrancy has been detected.. + + + + + Looks up a localized string similar to Observer has already terminated.. + + + + + Looks up a localized string similar to This scheduler operation has already been awaited.. + + + + diff --git a/packages/Rx-Core.2.1.30214.0/lib/Net45/System.Reactive.Core.dll b/packages/Rx-Core.2.1.30214.0/lib/Net45/System.Reactive.Core.dll new file mode 100644 index 0000000000000000000000000000000000000000..e338eafbd51637e13648c39a66b6e1c772f9624a GIT binary patch literal 121416 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 + + + System.Reactive.Core + + + + + The System.Reactive.PlatformServices namespace contains interfaces and classes used by the runtime infrastructure of Reactive Extensions. + Those are not intended to be used directly from user code and are subject to change in future releases of the product. + + + + + Provides a set of static methods for subscribing delegates to observables. + + + + + Subscribes to the observable sequence without specifying any handlers. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + IDisposable object used to unsubscribe from the observable sequence. + is null. + + + + Subscribes an element handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or or is null. + + + + Subscribes an observer to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer to subscribe to the sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or is null. + + + + Subscribes to the observable sequence without specifying any handlers, using a CancellationToken to support unsubscription. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + CancellationToken that can be signaled to unsubscribe from the source sequence. + is null. + + + + Subscribes an element handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or or is null. + + + + Subscribes to the specified source, re-routing synchronous exceptions during invocation of the Subscribe method to the observer's OnError channel. + This method is typically used when writing query operators. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer that will be passed to the observable sequence, and that will be used for exception propagation. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Provides a set of static methods for creating observers. + + + + + Creates an observer from a notification callback. + + The type of the elements received by the observer. + Action that handles a notification. + The observer object that invokes the specified handler using a notification corresponding to each message it receives. + is null. + + + + Creates a notification callback from an observer. + + The type of the elements received by the observer. + Observer object. + The action that forwards its input notification to the underlying observer. + is null. + + + + Creates an observer from the specified OnNext action. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + The observer object implemented using the given actions. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or or is null. + + + + Hides the identity of an observer. + + The type of the elements received by the source observer. + An observer whose identity to hide. + An observer that hides the identity of the specified observer. + is null. + + + + Checks access to the observer for grammar violations. This includes checking for multiple OnError or OnCompleted calls, as well as reentrancy in any of the observer methods. + If a violation is detected, an InvalidOperationException is thrown from the offending observer method call. + + The type of the elements received by the source observer. + The observer whose callback invocations should be checked for grammar violations. + An observer that checks callbacks invocations against the observer grammar and, if the checks pass, forwards those to the specified observer. + is null. + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently from multiple threads. This overload is useful when coordinating access to an observer. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload, passing true for the second parameter. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently. This overload is useful when coordinating access to an observer. + The parameter configures the type of lock used for synchronization. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + If set to true, reentrant observer callbacks will be queued up and get delivered to the observer in a sequential manner. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + When the parameter is set to false, behavior is identical to the overload which uses + a Monitor for synchronization. When the parameter is set to true, an + is used to queue up callbacks to the specified observer if a reentrant call is made. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently by multiple threads, using the specified gate object for use by a Monitor-based lock. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common gate object. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently, using the specified asynchronous lock to protect against concurrent and reentrant access. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common asynchronous lock. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + + + Schedules the invocation of observer methods on the given scheduler. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Scheduler to schedule observer messages on. + Observer whose messages are scheduled on the given scheduler. + or is null. + + + + Schedules the invocation of observer methods on the given synchonization context. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Synchonization context to schedule observer messages on. + Observer whose messages are scheduled on the given synchonization context. + or is null. + + + + Converts an observer to a progress object. + + The type of the progress objects received by the source observer. + The observer to convert. + Progress object whose Report messages correspond to the observer's OnNext messages. + is null. + + + + Converts an observer to a progress object, using the specified scheduler to invoke the progress reporting method. + + The type of the progress objects received by the source observer. + The observer to convert. + Scheduler to report progress on. + Progress object whose Report messages correspond to the observer's OnNext messages. + or is null. + + + + Converts a progress object to an observer. + + The type of the progress objects received by the progress reporter. + The progress object to convert. + Observer whose OnNext messages correspond to the progress object's Report messages. + is null. + + + + Class to create an IObservable<T> instance from a delegate-based implementation of the Subscribe method. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObservable<T> interface. + + + If you don't need a named type to create an observable sequence (i.e. you rather need + an instance rather than a reusable type), use the Observable.Create method to create + an observable sequence with specified subscription behavior. + + The type of the elements in the sequence. + + + + Subscribes the given observer to the observable sequence. + + Observer that will receive notifications from the observable sequence. + Disposable object representing an observer's subscription to the observable sequence. + is null. + + + + Implement this method with the core subscription logic for the observable sequence. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Creates an observable sequence object from the specified subscription function. + + Subscribe method implementation. + is null. + + + + Calls the subscription function that was supplied to the constructor. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Class to create an IObserver<T> instance from delegate-based implementations of the On* methods. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObserver<T> interface. + + This base class enforces the grammar of observers where OnError and OnCompleted are terminal messages. + The type of the elements in the sequence. + + + + Creates a new observer in a non-stopped state. + + + + + Notifies the observer of a new element in the sequence. + + Next element in the sequence. + + + + Implement this method to react to the receival of a new element in the sequence. + + Next element in the sequence. + This method only gets called when the observer hasn't stopped yet. + + + + Notifies the observer that an exception has occurred. + + The error that has occurred. + is null. + + + + Implement this method to react to the occurrence of an exception. + + The error that has occurred. + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Notifies the observer of the end of the sequence. + + + + + Implement this method to react to the end of the sequence. + + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Disposes the observer, causing it to transition to the stopped state. + + + + + Core implementation of IDisposable. + + true if the Dispose call was triggered by the IDisposable.Dispose method; false if it was triggered by the finalizer. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + or or is null. + + + + Creates an observer from the specified OnNext action. + + Observer's OnNext action implementation. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + or is null. + + + + Calls the onNext action. + + Next element in the sequence. + + + + Calls the onError action. + + The error that has occurred. + + + + Calls the onCompleted action. + + + + + This class fuses logic from ObserverBase, AnonymousObserver, and SafeObserver into one class. When an observer + needs to be safeguarded, an instance of this type can be created by SafeObserver.Create when it detects its + input is an AnonymousObserver, which is commonly used by end users when using the Subscribe extension methods + that accept delegates for the On* handlers. By doing the fusion, we make the call stack depth shorter which + helps debugging and some performance. + + + + + Asynchronous lock. + + + + + Queues the action for execution. If the caller acquires the lock and becomes the owner, + the queue is processed. If the lock is already owned, the action is queued and will get + processed by the owner. + + Action to queue for execution. + is null. + + + + Clears the work items in the queue and drops further work being queued. + + + + + (Infrastructure) Concurrency abstraction layer. + + + + + Gets the current CAL. If no CAL has been set yet, it will be initialized to the default. + + + + + (Infrastructure) Concurrency abstraction layer interface. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Queues a method for execution at the specified relative time. + + Method to execute. + State to pass to the method. + Time to execute the method on. + Disposable object that can be used to stop the timer. + + + + Queues a method for periodic execution based on the specified period. + + Method to execute; should be safe for reentrancy. + Period for running the method periodically. + Disposable object that can be used to stop the timer. + + + + Queues a method for execution. + + Method to execute. + State to pass to the method. + Disposable object that can be used to cancel the queued method. + + + + Blocking sleep operation. + + Time to sleep. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Starts a new long-running thread. + + Method to execute. + State to pass to the method. + + + + Gets whether long-running scheduling is supported. + + + + + Provides a set of static properties to access commonly used schedulers. + + + + + Returns a scheduler that represents the original scheduler, without any of its interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable all optimizations for. + Proxy to the original scheduler but without any optimizations enabled. + is null. + + + + Returns a scheduler that represents the original scheduler, without the specified set of interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable the specified optimizations for. + Types of the optimization interfaces that have to be disabled. + Proxy to the original scheduler but without the specified optimizations enabled. + or is null. + + + + Returns a scheduler that wraps the original scheduler, adding exception handling for scheduled actions. + + Type of the exception to check for. + Scheduler to apply an exception filter for. + Handler that's run if an exception is caught. The exception will be rethrown if the handler returns false. + Wrapper around the original scheduler, enforcing exception handling. + or is null. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + The scheduler to run periodic work on. + 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). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + Scheduler to execute the action on. + State passed to the action to be executed. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + Scheduler to execute the action on. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Starts a new stopwatch object by dynamically discovering the scheduler's capabilities. + If the scheduler provides stopwatch functionality, the request will be forwarded to the stopwatch provider implementation. + Otherwise, the stopwatch will be emulated using the scheduler's notion of absolute time. + + Scheduler to obtain a stopwatch for. + New stopwatch object; started at the time of the request. + is null. + The resulting stopwatch object can have non-monotonic behavior. + + + + Returns the ISchedulerLongRunning implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the ISchedulerLongRunning implementation for. + The scheduler's ISchedulerLongRunning implementation if available; null otherwise. + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using in case a stopwatch is required, but use of emulation stopwatch based + on the scheduler's clock is acceptable. Use of this method is recommended for best-effort use of the stopwatch provider + scheduler service, where the caller falls back to not using stopwatches if this facility wasn't found. + + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using the Scheduler.SchedulePeriodic extension methods for IScheduler in case periodic scheduling is required and + emulation of periodic behavior using other scheduler services is desirable. Use of this method is recommended for best-effort + use of the periodic scheduling service, where the caller falls back to not using periodic scheduling if this facility wasn't + found. + + + + + + Yields execution of the current work item on the scheduler to another work item on the scheduler. + The caller should await the result of calling Yield to schedule the remainder of the current work item (known as the continuation). + + Scheduler to yield work on. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Yields execution of the current work item on the scheduler to another work item on the scheduler. + The caller should await the result of calling Yield to schedule the remainder of the current work item (known as the continuation). + + Scheduler to yield work on. + Cancellation token to cancel the continuation to run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler for the specified duration. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) after the specified duration. + + Scheduler to yield work on. + Time when the continuation should run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler for the specified duration. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) after the specified duration. + + Scheduler to yield work on. + Time when the continuation should run. + Cancellation token to cancel the continuation to run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler until the specified due time. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) at the specified due time. + + Scheduler to yield work on. + Time when the continuation should run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler until the specified due time. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) at the specified due time. + + Scheduler to yield work on. + Time when the continuation should run. + Cancellation token to cancel the continuation to run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Normalizes the specified TimeSpan value to a positive value. + + The TimeSpan value to normalize. + The specified TimeSpan value if it is zero or positive; otherwise, TimeSpan.Zero. + + + + Schedules an action to be executed recursively. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in recursive invocation state. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified relative time. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified absolute time. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed after the specified relative due time. + + Scheduler to execute the action on. + Action to execute. + Relative time after which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at the specified absolute due time. + + Scheduler to execute the action on. + Action to execute. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Gets the current time according to the local machine's system clock. + + + + + Gets a scheduler that schedules work immediately on the current thread. + + + + + Gets a scheduler that schedules work as soon as possible on the current thread. + + + + + Gets a scheduler that schedules work on the platform's default scheduler. + + + + + Gets a scheduler that schedules work on the thread pool. + + + + + Gets a scheduler that schedules work on a new thread using default thread creation options. + + + + + Gets a scheduler that schedules work on Task Parallel Library (TPL) task pool using the default TaskScheduler. + + + + + Abstract base class for machine-local schedulers, using the local system clock for time-based operations. + + + + + Maximum error ratio for timer drift. We've seen machines with 10s drift on a + daily basis, which is in the order 10E-4, so we allow for extra margin here. + This value is used to calculate early arrival for the long term queue timer + that will reevaluate work for the short term queue. + + Example: -------------------------------...---------------------*-----$ + ^ ^ + | | + early due + 0.999 1.0 + + We also make the gap between early and due at least LONGTOSHORT so we have + enough time to transition work to short term and as a courtesy to the + destination scheduler to manage its queues etc. + + + + + Gate to protect queues and to synchronize scheduling decisions and system clock + change management. + + + + + Long term work queue. Contains work that's due beyond SHORTTERM, computed at the + time of enqueueing. + + + + + Disposable resource for the long term timer that will reevaluate and dispatch the + first item in the long term queue. A serial disposable is used to make "dispose + current and assign new" logic easier. The disposable itself is never disposed. + + + + + Item at the head of the long term queue for which the current long term timer is + running. Used to detect changes in the queue and decide whether we should replace + or can continue using the current timer (because no earlier long term work was + added to the queue). + + + + + Short term work queue. Contains work that's due soon, computed at the time of + enqueueing or upon reevaluation of the long term queue causing migration of work + items. This queue is kept in order to be able to relocate short term items back + to the long term queue in case a system clock change occurs. + + + + + Set of disposable handles to all of the current short term work Schedule calls, + allowing those to be cancelled upon a system clock change. + + + + + Threshold where an item is considered to be short term work or gets moved from + long term to short term. + + + + + Minimum threshold for the long term timer to fire before the queue is reevaluated + for short term work. This value is chosen to be less than SHORTTERM in order to + ensure the timer fires and has work to transition to the short term queue. + + + + + Threshold used to determine when a short term timer has fired too early compared + to the absolute due time. This provides a last chance protection against early + completion of scheduled work, which can happen in case of time adjustment in the + operating system (cf. GetSystemTimeAdjustment). + + + + + Enqueues absolute time scheduled work in the timer queue or the short term work list. + + Scheduler to run the work on. Typically "this" from the caller's perspective (LocalScheduler.Schedule), but parameter kept because we have a single (static) timer queue across all of Rx local schedulers. + State to pass to the action. + Absolute time to run the work on. The timer queue is responsible to execute the work close to the specified time, also accounting for system clock changes. + Action to run, potentially recursing into the scheduler. + Disposable object to prevent the work from running. + + + + Schedule work that's due in the short term. This leads to relative scheduling calls to the + underlying scheduler for short TimeSpan values. If the system clock changes in the meantime, + the short term work is attempted to be cancelled and reevaluated. + + Work item to schedule in the short term. The caller is responsible to determine the work is indeed short term. + + + + Callback to process the next short term work item. + + Recursive scheduler supplied by the underlying scheduler. + Disposable used to identify the work the timer was triggered for (see code for usage). + Empty disposable. Recursive work cancellation is wired through the original WorkItem. + + + + Schedule work that's due on the long term. This leads to the work being queued up for + eventual transitioning to the short term work list. + + Work item to schedule on the long term. The caller is responsible to determine the work is indeed long term. + + + + Updates the long term timer which is responsible to transition work from the head of the + long term queue to the short term work list. + + Should be called under the scheduler lock. + + + + Evaluates the long term queue, transitioning short term work to the short term list, + and adjusting the new long term processing timer accordingly. + + Ignored. + + + + Callback invoked when a system clock change is observed in order to adjust and reevaluate + the internal scheduling queues. + + Currently not used. + Currently not used. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + Platform-specific scheduler implementations should reimplement IStopwatchProvider to provide a more + efficient IStopwatch implementation (if available). + + + + + Discovers scheduler services by interface type. The base class implementation returns + requested services for each scheduler interface implemented by the derived class. For + more control over service discovery, derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the scheduler's notion of current time. + + + + + Represents a work item in the absolute time scheduler. + + + This type is very similar to ScheduledItem, but we need a different Invoke signature to allow customization + of the target scheduler (e.g. when called in a recursive scheduling context, see ExecuteNextShortTermWorkItem). + + + + + Represents a work item that closes over scheduler invocation state. Subtyping is + used to have a common type for the scheduler queues. + + + + + Represents an object that schedules units of work on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the current thread scheduler. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Represents an object that schedules units of work to run immediately on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the immediate scheduler. + + + + + Abstract base class for scheduled work items. + + Absolute time representation type. + + + + Creates a new scheduled work item to run at the specified time. + + Absolute time at which the work item has to be executed. + Comparer used to compare work items based on their scheduled time. + is null. + + + + Invokes the work item. + + + + + Implement this method to perform the work item invocation, returning a disposable object for deep cancellation. + + Disposable object used to cancel the work item and/or derived work items. + + + + Compares the work item with another work item based on absolute time values. + + Work item to compare the current work item to. + Relative ordering between this and the specified work item. + The inequality operators are overloaded to provide results consistent with the IComparable implementation. Equality operators implement traditional reference equality semantics. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before or at the same of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after or at the same time of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are equal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are equal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are inequal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are inequal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether a ScheduledItem<TAbsolute> object is equal to the specified object. + + The object to compare to the current ScheduledItem<TAbsolute> object. + true if the obj parameter is a ScheduledItem<TAbsolute> object and is equal to the current ScheduledItem<TAbsolute> object; otherwise, false. + + + + Returns the hash code for the current ScheduledItem<TAbsolute> object. + + A 32-bit signed integer hash code. + + + + Cancels the work item by disposing the resource returned by InvokeCore as soon as possible. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Gets whether the work item has received a cancellation request. + + + + + Represents a scheduled work item based on the materialization of an IScheduler.Schedule method call. + + Absolute time representation type. + Type of the state passed to the scheduled action. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + Comparer used to compare work items based on their scheduled time. + or or is null. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + or is null. + + + + Invokes the scheduled action with the supplied recursive scheduler and state. + + Cancellation resource returned by the scheduled action. + + + + Represents an awaitable scheduler operation. Awaiting the object causes the continuation to be posted back to the originating scheduler's work queue. + + + + + Controls whether the continuation is run on the originating synchronization context (false by default). + + true to run the continuation on the captured synchronization context; false otherwise (default). + Scheduler operation object with configured await behavior. + + + + Gets an awaiter for the scheduler operation, used to post back the continuation. + + Awaiter for the scheduler operation. + + + + (Infrastructure) Scheduler operation awaiter type used by the code generated for C# await and Visual Basic Await expressions. + + + + + Completes the scheduler operation, throwing an OperationCanceledException in case cancellation was requested. + + + + + Registers the continuation with the scheduler operation. + + Continuation to be run on the originating scheduler. + + + + Indicates whether the scheduler operation has completed. Returns false unless cancellation was already requested. + + + + + Efficient scheduler queue that maintains scheduled items sorted by absolute time. + + Absolute time representation type. + This type is not thread safe; users should ensure proper synchronization. + + + + Creates a new scheduler queue with a default initial capacity. + + + + + Creats a new scheduler queue with the specified initial capacity. + + Initial capacity of the scheduler queue. + is less than zero. + + + + Enqueues the specified work item to be scheduled. + + Work item to be scheduled. + + + + Removes the specified work item from the scheduler queue. + + Work item to be removed from the scheduler queue. + true if the item was found; false otherwise. + + + + Dequeues the next work item from the scheduler queue. + + Next work item in the scheduler queue (removed). + + + + Peeks the next work item in the scheduler queue. + + Next work item in the scheduler queue (not removed). + + + + Gets the number of scheduled items in the scheduler queue. + + + + + Provides basic synchronization and scheduling services for observable sequences. + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified scheduler. + In order to invoke observer callbacks on the specified scheduler, e.g. to offload callback processing to a dedicated thread, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified synchronization context. + In order to invoke observer callbacks on the specified synchronization context, e.g. to post callbacks to a UI thread represented by the synchronization context, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + + + Wraps the source sequence in order to ensure observer callbacks are properly serialized. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + + + Wraps the source sequence in order to ensure observer callbacks are synchronized using the specified gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Base class for implementation of query operators, providing performance benefits over the use of Observable.Create. + + Type of the resulting sequence's elements. + + + + Interface with variance annotation; allows for better type checking when detecting capabilities in SubscribeSafe. + + Type of the resulting sequence's elements. + + + + Publicly visible Subscribe method. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + IDisposable to cancel the subscription. This causes the underlying sink to be notified of unsubscription, causing it to prevent further messages from being sent to the observer. + + + + Core implementation of the query operator, called upon a new subscription to the producer object. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + The subscription disposable object returned from the Run call, passed in such that it can be forwarded to the sink, allowing it to dispose the subscription upon sending a final message (or prematurely for other reasons). + Callback to communicate the sink object to the subscriber, allowing consumers to tunnel a Dispose call into the sink, which can stop the processing. + Disposable representing all the resources and/or subscriptions the operator uses to process events. + The observer passed in to this method is not protected using auto-detach behavior upon an OnError or OnCompleted call. The implementation must ensure proper resource disposal and enforce the message grammar. + + + + Base class for implementation of query operators, providing a lightweight sink that can be disposed to mute the outgoing observer. + + Type of the resulting sequence's elements. + Implementations of sinks are responsible to enforce the message grammar on the associated observer. Upon sending a terminal message, a pairing Dispose call should be made to trigger cancellation of related resources and to mute the outgoing observer. + + + + Represents an object that schedules units of work on a provided . + + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + is null. + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + Configures whether scheduling always posts to the synchronization context, regardless whether the caller is on the same synchronization context. + is null. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Represents an object that schedules units of work on the platform's default scheduler. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a System.Threading.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. + + + + Schedules a periodic piece of work, using a System.Threading.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 less than TimeSpan.Zero. + is null. + + + + Discovers scheduler services by interface type. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the singleton instance of the default scheduler. + + + + + Represents an Action-based disposable. + + + + + Constructs a new disposable with the given action used for disposal. + + Disposal action which will be run upon calling Dispose. + + + + Calls the disposal action if and only if the current instance hasn't been disposed yet. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that can be checked for disposal status. + + + + + Initializes a new instance of the class. + + + + + Sets the status to disposed, which can be observer through the property. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that has an associated that will be set to the cancellation requested state upon disposal. + + + + + Initializes a new instance of the class that uses an existing . + + used for cancellation. + is null. + + + + Initializes a new instance of the class that uses a new . + + + + + Cancels the underlying . + + + + + Gets the used by this CancellationDisposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a group of disposable resources that are disposed together. + + + + + Initializes a new instance of the class with no disposables contained by it initially. + + + + + Initializes a new instance of the class with the specified number of disposables. + + The number of disposables that the new CompositeDisposable can initially store. + is less than zero. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed. + + Disposable to add. + is null. + + + + Removes and disposes the first occurrence of a disposable from the CompositeDisposable. + + Disposable to remove. + true if found; false otherwise. + is null. + + + + Disposes all disposables in the group and removes them from the group. + + + + + Removes and disposes all disposables from the CompositeDisposable, but does not dispose the CompositeDisposable. + + + + + Determines whether the CompositeDisposable contains a specific disposable. + + Disposable to search for. + true if the disposable was found; otherwise, false. + is null. + + + + Copies the disposables contained in the CompositeDisposable to an array, starting at a particular array index. + + Array to copy the contained disposables to. + Target index at which to copy the first disposable of the group. + is null. + is less than zero. -or - is larger than or equal to the array length. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Gets the number of disposables contained in the CompositeDisposable. + + + + + Always returns false. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be posted to the specified . + + + + + Initializes a new instance of the class that uses the specified on which to dispose the specified disposable resource. + + Context to perform disposal on. + Disposable whose Dispose operation to run on the given synchronization context. + or is null. + + + + Disposes the underlying disposable on the provided . + + + + + Gets the provided . + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable that does nothing on disposal. + + + + + Singleton default disposable. + + + + + Does nothing. + + + + + Provides a set of static methods for creating Disposables. + + + + + Creates a disposable object that invokes the specified action when disposed. + + Action to run during the first call to . The action is guaranteed to be run at most once. + The disposable object that runs the given action upon disposal. + is null. + + + + Gets the disposable that does nothing when disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be swapped for another disposable resource. + + + + + Initializes a new instance of the class with no current underlying disposable. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + If the MutableDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. + + + + Represents a disposable resource that only disposes its underlying disposable resource when all dependent disposable objects have been disposed. + + + + + Initializes a new instance of the class with the specified disposable. + + Underlying disposable. + is null. + + + + Returns a dependent disposable that when disposed decreases the refcount on the underlying disposable. + + A dependent disposable contributing to the reference count that manages the underlying disposable's lifetime. + + + + Disposes the underlying disposable only when all dependent disposables have been disposed. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be scheduled on the specified . + + + + + Initializes a new instance of the class that uses an on which to dispose the disposable. + + Scheduler where the disposable resource will be disposed on. + Disposable resource to dispose on the given scheduler. + or is null. + + + + Disposes the wrapped disposable on the provided scheduler. + + + + + Gets the scheduler where the disposable resource will be disposed on. + + + + + Gets the underlying disposable. After disposal, the result is undefined. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be replaced by another disposable resource, causing automatic disposal of the previous underlying disposable resource. + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. + + If the SerialDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. Assigning this property disposes the previous disposable object. + + + + Represents a disposable resource which only allows a single assignment of its underlying disposable resource. + If an underlying disposable resource has already been set, future attempts to set the underlying disposable resource will throw an . + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + Thrown if the SingleAssignmentDisposable has already been assigned to. + + + + (Infrastructure) Services to rethrow exceptions. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Rethrows the specified exception. + + Exception to rethrow. + + + + (Infrastructure) Provides access to the host's lifecycle management services. + + + + + Adds a reference to the host lifecycle manager, causing it to be sending notifications. + + + + + Removes a reference to the host lifecycle manager, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Event that gets raised when the host suspends the application. + + + + + Event that gets raised when the host resumes the application. + + + + + (Infrastructure) Provides notifications about the host's lifecycle events. + + + + + Event that gets raised when the host suspends. + + + + + Event that gets raised when the host resumes. + + + + + (Infrastructure) Event arguments for host suspension events. + + + + + (Infrastructure) Event arguments for host resumption events. + + + + + (Infrastructure) Interface for enlightenment providers. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Gets the current enlightenment provider. If none is loaded yet, accessing this property triggers provider resolution. + + + This member is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Provides access to local system clock services. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Adds a reference to the system clock monitor, causing it to be sending notifications. + + Thrown when the system doesn't support sending clock change notifications. + + + + Removes a reference to the system clock monitor, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Gets the local system clock time. + + + + + Event that gets raised when a system clock change is detected, if there's any interest as indicated by AddRef calls. + + + + + (Infrastructure) Provides access to the local system clock. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Gets the current time. + + + + + (Infrastructure) Provides a mechanism to notify local schedulers about system clock changes. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Event that gets raised when a system clock change is detected. + + + + + (Infrastructure) Event arguments for system clock change notifications. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Creates a new system clock notification object with unknown old and new times. + + + + + Creates a new system clock notification object with the specified old and new times. + + Time before the system clock changed, or DateTimeOffset.MinValue if not known. + Time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + Gets the time before the system clock changed, or DateTimeOffset.MinValue if not known. + + + + + Gets the time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + + (Infrastructure) Provides access to the local system clock. + + + + + Gets the current time. + + + + + (Infrastructure) Monitors for system clock changes based on a periodic timer. + + + + + Creates a new monitor for system clock changes with the specified polling frequency. + + Polling frequency for system clock changes. + + + + Event that gets raised when a system clock change is detected. + + + + + Indicates the type of a notification. + + + + + Represents an OnNext notification. + + + + + Represents an OnError notification. + + + + + Represents an OnCompleted notification. + + + + + Represents a notification to an observer. + + The type of the elements received by the observer. + + + + Default constructor used by derived types. + + + + + Determines whether the current Notification<T> object has the same observer message payload as a specified Notification<T> value. + + An object to compare to the current Notification<T> object. + true if both Notification<T> objects have the same observer message payload; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have the same observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has the same observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have a different observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has a different observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent a different observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the specified System.Object is equal to the current Notification<T>. + + The System.Object to compare with the current Notification<T>. + true if the specified System.Object is equal to the current Notification<T>; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + The type of the result returned from the observer's notification handlers. + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + The type of the result returned from the notification handler delegates. + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns an observable sequence with a single notification, using the immediate scheduler. + + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns an observable sequence with a single notification. + + Scheduler to send out the notification calls on. + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns the value of an OnNext notification or throws an exception. + + + + + Returns a value that indicates whether the notification has a value. + + + + + Returns the exception of an OnError notification or returns null. + + + + + Gets the kind of notification that is represented. + + + + + Represents an OnNext notification to an observer. + + + + + Constructs a notification of a new value. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and a specified object are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns the value of an OnNext notification. + + + + + Returns null. + + + + + Returns true. + + + + + Returns NotificationKind.OnNext. + + + + + Represents an OnError notification to an observer. + + + + + Constructs a notification of an exception. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws the exception. + + + + + Returns the exception. + + + + + Returns false. + + + + + Returns NotificationKind.OnError. + + + + + Represents an OnCompleted notification to an observer. + + + + + Constructs a notification of the end of a sequence. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws an InvalidOperationException. + + + + + Returns null. + + + + + Returns false. + + + + + Returns NotificationKind.OnCompleted. + + + + + Provides a set of static methods for constructing notifications. + + + + + Creates an object that represents an OnNext notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The value contained in the notification. + The OnNext notification containing the value. + + + + Creates an object that represents an OnError notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The exception contained in the notification. + The OnError notification containing the exception. + is null. + + + + Creates an object that represents an OnCompleted notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The OnCompleted notification. + + + + Represents a type with a single value. This type is often used to denote the successful completion of a void-returning method (C#) or a Sub procedure (Visual Basic). + + + + + Determines whether the specified Unit values is equal to the current Unit. Because Unit has a single value, this always returns true. + + An object to compare to the current Unit value. + Because Unit has a single value, this always returns true. + + + + Determines whether the specified System.Object is equal to the current Unit. + + The System.Object to compare with the current Unit. + true if the specified System.Object is a Unit value; otherwise, false. + + + + Returns the hash code for the current Unit value. + + A hash code for the current Unit value. + + + + Returns a string representation of the current Unit value. + + String representation of the current Unit value. + + + + Determines whether the two specified Unit values are equal. Because Unit has a single value, this always returns true. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns true. + + + + Determines whether the two specified Unit values are not equal. Because Unit has a single value, this always returns false. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns false. + + + + Gets the single unit value. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + 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.. + + + + + Looks up a localized string similar to OnCompleted notification doesn't have a value.. + + + + + Looks up a localized string similar to Disposable has already been assigned.. + + + + + Looks up a localized string similar to Failed to start monitoring system clock changes.. + + + + + Looks up a localized string similar to Heap is empty.. + + + + + Looks up a localized string similar to Reentrancy has been detected.. + + + + + Looks up a localized string similar to Observer has already terminated.. + + + + + Looks up a localized string similar to This scheduler operation has already been awaited.. + + + + diff --git a/packages/Rx-Core.2.1.30214.0/lib/NetCore45/System.Reactive.Core.dll b/packages/Rx-Core.2.1.30214.0/lib/NetCore45/System.Reactive.Core.dll new file mode 100644 index 0000000000000000000000000000000000000000..e338eafbd51637e13648c39a66b6e1c772f9624a GIT binary patch literal 121416 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 + + + System.Reactive.Core + + + + + The System.Reactive.PlatformServices namespace contains interfaces and classes used by the runtime infrastructure of Reactive Extensions. + Those are not intended to be used directly from user code and are subject to change in future releases of the product. + + + + + Provides a set of static methods for subscribing delegates to observables. + + + + + Subscribes to the observable sequence without specifying any handlers. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + IDisposable object used to unsubscribe from the observable sequence. + is null. + + + + Subscribes an element handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or or is null. + + + + Subscribes an observer to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer to subscribe to the sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or is null. + + + + Subscribes to the observable sequence without specifying any handlers, using a CancellationToken to support unsubscription. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + CancellationToken that can be signaled to unsubscribe from the source sequence. + is null. + + + + Subscribes an element handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or or is null. + + + + Subscribes to the specified source, re-routing synchronous exceptions during invocation of the Subscribe method to the observer's OnError channel. + This method is typically used when writing query operators. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer that will be passed to the observable sequence, and that will be used for exception propagation. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Provides a set of static methods for creating observers. + + + + + Creates an observer from a notification callback. + + The type of the elements received by the observer. + Action that handles a notification. + The observer object that invokes the specified handler using a notification corresponding to each message it receives. + is null. + + + + Creates a notification callback from an observer. + + The type of the elements received by the observer. + Observer object. + The action that forwards its input notification to the underlying observer. + is null. + + + + Creates an observer from the specified OnNext action. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + The observer object implemented using the given actions. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or or is null. + + + + Hides the identity of an observer. + + The type of the elements received by the source observer. + An observer whose identity to hide. + An observer that hides the identity of the specified observer. + is null. + + + + Checks access to the observer for grammar violations. This includes checking for multiple OnError or OnCompleted calls, as well as reentrancy in any of the observer methods. + If a violation is detected, an InvalidOperationException is thrown from the offending observer method call. + + The type of the elements received by the source observer. + The observer whose callback invocations should be checked for grammar violations. + An observer that checks callbacks invocations against the observer grammar and, if the checks pass, forwards those to the specified observer. + is null. + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently from multiple threads. This overload is useful when coordinating access to an observer. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload, passing true for the second parameter. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently. This overload is useful when coordinating access to an observer. + The parameter configures the type of lock used for synchronization. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + If set to true, reentrant observer callbacks will be queued up and get delivered to the observer in a sequential manner. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + When the parameter is set to false, behavior is identical to the overload which uses + a Monitor for synchronization. When the parameter is set to true, an + is used to queue up callbacks to the specified observer if a reentrant call is made. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently by multiple threads, using the specified gate object for use by a Monitor-based lock. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common gate object. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently, using the specified asynchronous lock to protect against concurrent and reentrant access. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common asynchronous lock. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + + + Schedules the invocation of observer methods on the given scheduler. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Scheduler to schedule observer messages on. + Observer whose messages are scheduled on the given scheduler. + or is null. + + + + Schedules the invocation of observer methods on the given synchonization context. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Synchonization context to schedule observer messages on. + Observer whose messages are scheduled on the given synchonization context. + or is null. + + + + Converts an observer to a progress object. + + The type of the progress objects received by the source observer. + The observer to convert. + Progress object whose Report messages correspond to the observer's OnNext messages. + is null. + + + + Converts an observer to a progress object, using the specified scheduler to invoke the progress reporting method. + + The type of the progress objects received by the source observer. + The observer to convert. + Scheduler to report progress on. + Progress object whose Report messages correspond to the observer's OnNext messages. + or is null. + + + + Converts a progress object to an observer. + + The type of the progress objects received by the progress reporter. + The progress object to convert. + Observer whose OnNext messages correspond to the progress object's Report messages. + is null. + + + + Class to create an IObservable<T> instance from a delegate-based implementation of the Subscribe method. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObservable<T> interface. + + + If you don't need a named type to create an observable sequence (i.e. you rather need + an instance rather than a reusable type), use the Observable.Create method to create + an observable sequence with specified subscription behavior. + + The type of the elements in the sequence. + + + + Subscribes the given observer to the observable sequence. + + Observer that will receive notifications from the observable sequence. + Disposable object representing an observer's subscription to the observable sequence. + is null. + + + + Implement this method with the core subscription logic for the observable sequence. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Creates an observable sequence object from the specified subscription function. + + Subscribe method implementation. + is null. + + + + Calls the subscription function that was supplied to the constructor. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Class to create an IObserver<T> instance from delegate-based implementations of the On* methods. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObserver<T> interface. + + This base class enforces the grammar of observers where OnError and OnCompleted are terminal messages. + The type of the elements in the sequence. + + + + Creates a new observer in a non-stopped state. + + + + + Notifies the observer of a new element in the sequence. + + Next element in the sequence. + + + + Implement this method to react to the receival of a new element in the sequence. + + Next element in the sequence. + This method only gets called when the observer hasn't stopped yet. + + + + Notifies the observer that an exception has occurred. + + The error that has occurred. + is null. + + + + Implement this method to react to the occurrence of an exception. + + The error that has occurred. + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Notifies the observer of the end of the sequence. + + + + + Implement this method to react to the end of the sequence. + + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Disposes the observer, causing it to transition to the stopped state. + + + + + Core implementation of IDisposable. + + true if the Dispose call was triggered by the IDisposable.Dispose method; false if it was triggered by the finalizer. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + or or is null. + + + + Creates an observer from the specified OnNext action. + + Observer's OnNext action implementation. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + or is null. + + + + Calls the onNext action. + + Next element in the sequence. + + + + Calls the onError action. + + The error that has occurred. + + + + Calls the onCompleted action. + + + + + This class fuses logic from ObserverBase, AnonymousObserver, and SafeObserver into one class. When an observer + needs to be safeguarded, an instance of this type can be created by SafeObserver.Create when it detects its + input is an AnonymousObserver, which is commonly used by end users when using the Subscribe extension methods + that accept delegates for the On* handlers. By doing the fusion, we make the call stack depth shorter which + helps debugging and some performance. + + + + + Asynchronous lock. + + + + + Queues the action for execution. If the caller acquires the lock and becomes the owner, + the queue is processed. If the lock is already owned, the action is queued and will get + processed by the owner. + + Action to queue for execution. + is null. + + + + Clears the work items in the queue and drops further work being queued. + + + + + (Infrastructure) Concurrency abstraction layer. + + + + + Gets the current CAL. If no CAL has been set yet, it will be initialized to the default. + + + + + (Infrastructure) Concurrency abstraction layer interface. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Queues a method for execution at the specified relative time. + + Method to execute. + State to pass to the method. + Time to execute the method on. + Disposable object that can be used to stop the timer. + + + + Queues a method for periodic execution based on the specified period. + + Method to execute; should be safe for reentrancy. + Period for running the method periodically. + Disposable object that can be used to stop the timer. + + + + Queues a method for execution. + + Method to execute. + State to pass to the method. + Disposable object that can be used to cancel the queued method. + + + + Blocking sleep operation. + + Time to sleep. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Starts a new long-running thread. + + Method to execute. + State to pass to the method. + + + + Gets whether long-running scheduling is supported. + + + + + Provides a set of static properties to access commonly used schedulers. + + + + + Returns a scheduler that represents the original scheduler, without any of its interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable all optimizations for. + Proxy to the original scheduler but without any optimizations enabled. + is null. + + + + Returns a scheduler that represents the original scheduler, without the specified set of interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable the specified optimizations for. + Types of the optimization interfaces that have to be disabled. + Proxy to the original scheduler but without the specified optimizations enabled. + or is null. + + + + Returns a scheduler that wraps the original scheduler, adding exception handling for scheduled actions. + + Type of the exception to check for. + Scheduler to apply an exception filter for. + Handler that's run if an exception is caught. The exception will be rethrown if the handler returns false. + Wrapper around the original scheduler, enforcing exception handling. + or is null. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + The scheduler to run periodic work on. + 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). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + Scheduler to execute the action on. + State passed to the action to be executed. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + Scheduler to execute the action on. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Starts a new stopwatch object by dynamically discovering the scheduler's capabilities. + If the scheduler provides stopwatch functionality, the request will be forwarded to the stopwatch provider implementation. + Otherwise, the stopwatch will be emulated using the scheduler's notion of absolute time. + + Scheduler to obtain a stopwatch for. + New stopwatch object; started at the time of the request. + is null. + The resulting stopwatch object can have non-monotonic behavior. + + + + Returns the ISchedulerLongRunning implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the ISchedulerLongRunning implementation for. + The scheduler's ISchedulerLongRunning implementation if available; null otherwise. + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using in case a stopwatch is required, but use of emulation stopwatch based + on the scheduler's clock is acceptable. Use of this method is recommended for best-effort use of the stopwatch provider + scheduler service, where the caller falls back to not using stopwatches if this facility wasn't found. + + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using the Scheduler.SchedulePeriodic extension methods for IScheduler in case periodic scheduling is required and + emulation of periodic behavior using other scheduler services is desirable. Use of this method is recommended for best-effort + use of the periodic scheduling service, where the caller falls back to not using periodic scheduling if this facility wasn't + found. + + + + + + Yields execution of the current work item on the scheduler to another work item on the scheduler. + The caller should await the result of calling Yield to schedule the remainder of the current work item (known as the continuation). + + Scheduler to yield work on. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Yields execution of the current work item on the scheduler to another work item on the scheduler. + The caller should await the result of calling Yield to schedule the remainder of the current work item (known as the continuation). + + Scheduler to yield work on. + Cancellation token to cancel the continuation to run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler for the specified duration. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) after the specified duration. + + Scheduler to yield work on. + Time when the continuation should run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler for the specified duration. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) after the specified duration. + + Scheduler to yield work on. + Time when the continuation should run. + Cancellation token to cancel the continuation to run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler until the specified due time. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) at the specified due time. + + Scheduler to yield work on. + Time when the continuation should run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler until the specified due time. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) at the specified due time. + + Scheduler to yield work on. + Time when the continuation should run. + Cancellation token to cancel the continuation to run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Normalizes the specified TimeSpan value to a positive value. + + The TimeSpan value to normalize. + The specified TimeSpan value if it is zero or positive; otherwise, TimeSpan.Zero. + + + + Schedules an action to be executed recursively. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in recursive invocation state. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified relative time. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified absolute time. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed after the specified relative due time. + + Scheduler to execute the action on. + Action to execute. + Relative time after which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at the specified absolute due time. + + Scheduler to execute the action on. + Action to execute. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Gets the current time according to the local machine's system clock. + + + + + Gets a scheduler that schedules work immediately on the current thread. + + + + + Gets a scheduler that schedules work as soon as possible on the current thread. + + + + + Gets a scheduler that schedules work on the platform's default scheduler. + + + + + Gets a scheduler that schedules work on the thread pool. + + + + + Gets a scheduler that schedules work on a new thread using default thread creation options. + + + + + Gets a scheduler that schedules work on Task Parallel Library (TPL) task pool using the default TaskScheduler. + + + + + Abstract base class for machine-local schedulers, using the local system clock for time-based operations. + + + + + Maximum error ratio for timer drift. We've seen machines with 10s drift on a + daily basis, which is in the order 10E-4, so we allow for extra margin here. + This value is used to calculate early arrival for the long term queue timer + that will reevaluate work for the short term queue. + + Example: -------------------------------...---------------------*-----$ + ^ ^ + | | + early due + 0.999 1.0 + + We also make the gap between early and due at least LONGTOSHORT so we have + enough time to transition work to short term and as a courtesy to the + destination scheduler to manage its queues etc. + + + + + Gate to protect queues and to synchronize scheduling decisions and system clock + change management. + + + + + Long term work queue. Contains work that's due beyond SHORTTERM, computed at the + time of enqueueing. + + + + + Disposable resource for the long term timer that will reevaluate and dispatch the + first item in the long term queue. A serial disposable is used to make "dispose + current and assign new" logic easier. The disposable itself is never disposed. + + + + + Item at the head of the long term queue for which the current long term timer is + running. Used to detect changes in the queue and decide whether we should replace + or can continue using the current timer (because no earlier long term work was + added to the queue). + + + + + Short term work queue. Contains work that's due soon, computed at the time of + enqueueing or upon reevaluation of the long term queue causing migration of work + items. This queue is kept in order to be able to relocate short term items back + to the long term queue in case a system clock change occurs. + + + + + Set of disposable handles to all of the current short term work Schedule calls, + allowing those to be cancelled upon a system clock change. + + + + + Threshold where an item is considered to be short term work or gets moved from + long term to short term. + + + + + Minimum threshold for the long term timer to fire before the queue is reevaluated + for short term work. This value is chosen to be less than SHORTTERM in order to + ensure the timer fires and has work to transition to the short term queue. + + + + + Threshold used to determine when a short term timer has fired too early compared + to the absolute due time. This provides a last chance protection against early + completion of scheduled work, which can happen in case of time adjustment in the + operating system (cf. GetSystemTimeAdjustment). + + + + + Enqueues absolute time scheduled work in the timer queue or the short term work list. + + Scheduler to run the work on. Typically "this" from the caller's perspective (LocalScheduler.Schedule), but parameter kept because we have a single (static) timer queue across all of Rx local schedulers. + State to pass to the action. + Absolute time to run the work on. The timer queue is responsible to execute the work close to the specified time, also accounting for system clock changes. + Action to run, potentially recursing into the scheduler. + Disposable object to prevent the work from running. + + + + Schedule work that's due in the short term. This leads to relative scheduling calls to the + underlying scheduler for short TimeSpan values. If the system clock changes in the meantime, + the short term work is attempted to be cancelled and reevaluated. + + Work item to schedule in the short term. The caller is responsible to determine the work is indeed short term. + + + + Callback to process the next short term work item. + + Recursive scheduler supplied by the underlying scheduler. + Disposable used to identify the work the timer was triggered for (see code for usage). + Empty disposable. Recursive work cancellation is wired through the original WorkItem. + + + + Schedule work that's due on the long term. This leads to the work being queued up for + eventual transitioning to the short term work list. + + Work item to schedule on the long term. The caller is responsible to determine the work is indeed long term. + + + + Updates the long term timer which is responsible to transition work from the head of the + long term queue to the short term work list. + + Should be called under the scheduler lock. + + + + Evaluates the long term queue, transitioning short term work to the short term list, + and adjusting the new long term processing timer accordingly. + + Ignored. + + + + Callback invoked when a system clock change is observed in order to adjust and reevaluate + the internal scheduling queues. + + Currently not used. + Currently not used. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + Platform-specific scheduler implementations should reimplement IStopwatchProvider to provide a more + efficient IStopwatch implementation (if available). + + + + + Discovers scheduler services by interface type. The base class implementation returns + requested services for each scheduler interface implemented by the derived class. For + more control over service discovery, derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the scheduler's notion of current time. + + + + + Represents a work item in the absolute time scheduler. + + + This type is very similar to ScheduledItem, but we need a different Invoke signature to allow customization + of the target scheduler (e.g. when called in a recursive scheduling context, see ExecuteNextShortTermWorkItem). + + + + + Represents a work item that closes over scheduler invocation state. Subtyping is + used to have a common type for the scheduler queues. + + + + + Represents an object that schedules units of work on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the current thread scheduler. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Represents an object that schedules units of work to run immediately on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the immediate scheduler. + + + + + Abstract base class for scheduled work items. + + Absolute time representation type. + + + + Creates a new scheduled work item to run at the specified time. + + Absolute time at which the work item has to be executed. + Comparer used to compare work items based on their scheduled time. + is null. + + + + Invokes the work item. + + + + + Implement this method to perform the work item invocation, returning a disposable object for deep cancellation. + + Disposable object used to cancel the work item and/or derived work items. + + + + Compares the work item with another work item based on absolute time values. + + Work item to compare the current work item to. + Relative ordering between this and the specified work item. + The inequality operators are overloaded to provide results consistent with the IComparable implementation. Equality operators implement traditional reference equality semantics. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before or at the same of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after or at the same time of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are equal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are equal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are inequal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are inequal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether a ScheduledItem<TAbsolute> object is equal to the specified object. + + The object to compare to the current ScheduledItem<TAbsolute> object. + true if the obj parameter is a ScheduledItem<TAbsolute> object and is equal to the current ScheduledItem<TAbsolute> object; otherwise, false. + + + + Returns the hash code for the current ScheduledItem<TAbsolute> object. + + A 32-bit signed integer hash code. + + + + Cancels the work item by disposing the resource returned by InvokeCore as soon as possible. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Gets whether the work item has received a cancellation request. + + + + + Represents a scheduled work item based on the materialization of an IScheduler.Schedule method call. + + Absolute time representation type. + Type of the state passed to the scheduled action. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + Comparer used to compare work items based on their scheduled time. + or or is null. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + or is null. + + + + Invokes the scheduled action with the supplied recursive scheduler and state. + + Cancellation resource returned by the scheduled action. + + + + Represents an awaitable scheduler operation. Awaiting the object causes the continuation to be posted back to the originating scheduler's work queue. + + + + + Controls whether the continuation is run on the originating synchronization context (false by default). + + true to run the continuation on the captured synchronization context; false otherwise (default). + Scheduler operation object with configured await behavior. + + + + Gets an awaiter for the scheduler operation, used to post back the continuation. + + Awaiter for the scheduler operation. + + + + (Infrastructure) Scheduler operation awaiter type used by the code generated for C# await and Visual Basic Await expressions. + + + + + Completes the scheduler operation, throwing an OperationCanceledException in case cancellation was requested. + + + + + Registers the continuation with the scheduler operation. + + Continuation to be run on the originating scheduler. + + + + Indicates whether the scheduler operation has completed. Returns false unless cancellation was already requested. + + + + + Efficient scheduler queue that maintains scheduled items sorted by absolute time. + + Absolute time representation type. + This type is not thread safe; users should ensure proper synchronization. + + + + Creates a new scheduler queue with a default initial capacity. + + + + + Creats a new scheduler queue with the specified initial capacity. + + Initial capacity of the scheduler queue. + is less than zero. + + + + Enqueues the specified work item to be scheduled. + + Work item to be scheduled. + + + + Removes the specified work item from the scheduler queue. + + Work item to be removed from the scheduler queue. + true if the item was found; false otherwise. + + + + Dequeues the next work item from the scheduler queue. + + Next work item in the scheduler queue (removed). + + + + Peeks the next work item in the scheduler queue. + + Next work item in the scheduler queue (not removed). + + + + Gets the number of scheduled items in the scheduler queue. + + + + + Provides basic synchronization and scheduling services for observable sequences. + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified scheduler. + In order to invoke observer callbacks on the specified scheduler, e.g. to offload callback processing to a dedicated thread, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified synchronization context. + In order to invoke observer callbacks on the specified synchronization context, e.g. to post callbacks to a UI thread represented by the synchronization context, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + + + Wraps the source sequence in order to ensure observer callbacks are properly serialized. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + + + Wraps the source sequence in order to ensure observer callbacks are synchronized using the specified gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Base class for implementation of query operators, providing performance benefits over the use of Observable.Create. + + Type of the resulting sequence's elements. + + + + Interface with variance annotation; allows for better type checking when detecting capabilities in SubscribeSafe. + + Type of the resulting sequence's elements. + + + + Publicly visible Subscribe method. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + IDisposable to cancel the subscription. This causes the underlying sink to be notified of unsubscription, causing it to prevent further messages from being sent to the observer. + + + + Core implementation of the query operator, called upon a new subscription to the producer object. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + The subscription disposable object returned from the Run call, passed in such that it can be forwarded to the sink, allowing it to dispose the subscription upon sending a final message (or prematurely for other reasons). + Callback to communicate the sink object to the subscriber, allowing consumers to tunnel a Dispose call into the sink, which can stop the processing. + Disposable representing all the resources and/or subscriptions the operator uses to process events. + The observer passed in to this method is not protected using auto-detach behavior upon an OnError or OnCompleted call. The implementation must ensure proper resource disposal and enforce the message grammar. + + + + Base class for implementation of query operators, providing a lightweight sink that can be disposed to mute the outgoing observer. + + Type of the resulting sequence's elements. + Implementations of sinks are responsible to enforce the message grammar on the associated observer. Upon sending a terminal message, a pairing Dispose call should be made to trigger cancellation of related resources and to mute the outgoing observer. + + + + Represents an object that schedules units of work on a provided . + + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + is null. + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + Configures whether scheduling always posts to the synchronization context, regardless whether the caller is on the same synchronization context. + is null. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Represents an object that schedules units of work on the platform's default scheduler. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a System.Threading.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. + + + + Schedules a periodic piece of work, using a System.Threading.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 less than TimeSpan.Zero. + is null. + + + + Discovers scheduler services by interface type. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the singleton instance of the default scheduler. + + + + + Represents an Action-based disposable. + + + + + Constructs a new disposable with the given action used for disposal. + + Disposal action which will be run upon calling Dispose. + + + + Calls the disposal action if and only if the current instance hasn't been disposed yet. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that can be checked for disposal status. + + + + + Initializes a new instance of the class. + + + + + Sets the status to disposed, which can be observer through the property. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that has an associated that will be set to the cancellation requested state upon disposal. + + + + + Initializes a new instance of the class that uses an existing . + + used for cancellation. + is null. + + + + Initializes a new instance of the class that uses a new . + + + + + Cancels the underlying . + + + + + Gets the used by this CancellationDisposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a group of disposable resources that are disposed together. + + + + + Initializes a new instance of the class with no disposables contained by it initially. + + + + + Initializes a new instance of the class with the specified number of disposables. + + The number of disposables that the new CompositeDisposable can initially store. + is less than zero. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed. + + Disposable to add. + is null. + + + + Removes and disposes the first occurrence of a disposable from the CompositeDisposable. + + Disposable to remove. + true if found; false otherwise. + is null. + + + + Disposes all disposables in the group and removes them from the group. + + + + + Removes and disposes all disposables from the CompositeDisposable, but does not dispose the CompositeDisposable. + + + + + Determines whether the CompositeDisposable contains a specific disposable. + + Disposable to search for. + true if the disposable was found; otherwise, false. + is null. + + + + Copies the disposables contained in the CompositeDisposable to an array, starting at a particular array index. + + Array to copy the contained disposables to. + Target index at which to copy the first disposable of the group. + is null. + is less than zero. -or - is larger than or equal to the array length. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Gets the number of disposables contained in the CompositeDisposable. + + + + + Always returns false. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be posted to the specified . + + + + + Initializes a new instance of the class that uses the specified on which to dispose the specified disposable resource. + + Context to perform disposal on. + Disposable whose Dispose operation to run on the given synchronization context. + or is null. + + + + Disposes the underlying disposable on the provided . + + + + + Gets the provided . + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable that does nothing on disposal. + + + + + Singleton default disposable. + + + + + Does nothing. + + + + + Provides a set of static methods for creating Disposables. + + + + + Creates a disposable object that invokes the specified action when disposed. + + Action to run during the first call to . The action is guaranteed to be run at most once. + The disposable object that runs the given action upon disposal. + is null. + + + + Gets the disposable that does nothing when disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be swapped for another disposable resource. + + + + + Initializes a new instance of the class with no current underlying disposable. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + If the MutableDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. + + + + Represents a disposable resource that only disposes its underlying disposable resource when all dependent disposable objects have been disposed. + + + + + Initializes a new instance of the class with the specified disposable. + + Underlying disposable. + is null. + + + + Returns a dependent disposable that when disposed decreases the refcount on the underlying disposable. + + A dependent disposable contributing to the reference count that manages the underlying disposable's lifetime. + + + + Disposes the underlying disposable only when all dependent disposables have been disposed. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be scheduled on the specified . + + + + + Initializes a new instance of the class that uses an on which to dispose the disposable. + + Scheduler where the disposable resource will be disposed on. + Disposable resource to dispose on the given scheduler. + or is null. + + + + Disposes the wrapped disposable on the provided scheduler. + + + + + Gets the scheduler where the disposable resource will be disposed on. + + + + + Gets the underlying disposable. After disposal, the result is undefined. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be replaced by another disposable resource, causing automatic disposal of the previous underlying disposable resource. + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. + + If the SerialDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. Assigning this property disposes the previous disposable object. + + + + Represents a disposable resource which only allows a single assignment of its underlying disposable resource. + If an underlying disposable resource has already been set, future attempts to set the underlying disposable resource will throw an . + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + Thrown if the SingleAssignmentDisposable has already been assigned to. + + + + (Infrastructure) Services to rethrow exceptions. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Rethrows the specified exception. + + Exception to rethrow. + + + + (Infrastructure) Provides access to the host's lifecycle management services. + + + + + Adds a reference to the host lifecycle manager, causing it to be sending notifications. + + + + + Removes a reference to the host lifecycle manager, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Event that gets raised when the host suspends the application. + + + + + Event that gets raised when the host resumes the application. + + + + + (Infrastructure) Provides notifications about the host's lifecycle events. + + + + + Event that gets raised when the host suspends. + + + + + Event that gets raised when the host resumes. + + + + + (Infrastructure) Event arguments for host suspension events. + + + + + (Infrastructure) Event arguments for host resumption events. + + + + + (Infrastructure) Interface for enlightenment providers. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Gets the current enlightenment provider. If none is loaded yet, accessing this property triggers provider resolution. + + + This member is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Provides access to local system clock services. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Adds a reference to the system clock monitor, causing it to be sending notifications. + + Thrown when the system doesn't support sending clock change notifications. + + + + Removes a reference to the system clock monitor, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Gets the local system clock time. + + + + + Event that gets raised when a system clock change is detected, if there's any interest as indicated by AddRef calls. + + + + + (Infrastructure) Provides access to the local system clock. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Gets the current time. + + + + + (Infrastructure) Provides a mechanism to notify local schedulers about system clock changes. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Event that gets raised when a system clock change is detected. + + + + + (Infrastructure) Event arguments for system clock change notifications. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Creates a new system clock notification object with unknown old and new times. + + + + + Creates a new system clock notification object with the specified old and new times. + + Time before the system clock changed, or DateTimeOffset.MinValue if not known. + Time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + Gets the time before the system clock changed, or DateTimeOffset.MinValue if not known. + + + + + Gets the time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + + (Infrastructure) Provides access to the local system clock. + + + + + Gets the current time. + + + + + (Infrastructure) Monitors for system clock changes based on a periodic timer. + + + + + Creates a new monitor for system clock changes with the specified polling frequency. + + Polling frequency for system clock changes. + + + + Event that gets raised when a system clock change is detected. + + + + + Indicates the type of a notification. + + + + + Represents an OnNext notification. + + + + + Represents an OnError notification. + + + + + Represents an OnCompleted notification. + + + + + Represents a notification to an observer. + + The type of the elements received by the observer. + + + + Default constructor used by derived types. + + + + + Determines whether the current Notification<T> object has the same observer message payload as a specified Notification<T> value. + + An object to compare to the current Notification<T> object. + true if both Notification<T> objects have the same observer message payload; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have the same observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has the same observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have a different observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has a different observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent a different observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the specified System.Object is equal to the current Notification<T>. + + The System.Object to compare with the current Notification<T>. + true if the specified System.Object is equal to the current Notification<T>; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + The type of the result returned from the observer's notification handlers. + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + The type of the result returned from the notification handler delegates. + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns an observable sequence with a single notification, using the immediate scheduler. + + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns an observable sequence with a single notification. + + Scheduler to send out the notification calls on. + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns the value of an OnNext notification or throws an exception. + + + + + Returns a value that indicates whether the notification has a value. + + + + + Returns the exception of an OnError notification or returns null. + + + + + Gets the kind of notification that is represented. + + + + + Represents an OnNext notification to an observer. + + + + + Constructs a notification of a new value. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and a specified object are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns the value of an OnNext notification. + + + + + Returns null. + + + + + Returns true. + + + + + Returns NotificationKind.OnNext. + + + + + Represents an OnError notification to an observer. + + + + + Constructs a notification of an exception. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws the exception. + + + + + Returns the exception. + + + + + Returns false. + + + + + Returns NotificationKind.OnError. + + + + + Represents an OnCompleted notification to an observer. + + + + + Constructs a notification of the end of a sequence. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws an InvalidOperationException. + + + + + Returns null. + + + + + Returns false. + + + + + Returns NotificationKind.OnCompleted. + + + + + Provides a set of static methods for constructing notifications. + + + + + Creates an object that represents an OnNext notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The value contained in the notification. + The OnNext notification containing the value. + + + + Creates an object that represents an OnError notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The exception contained in the notification. + The OnError notification containing the exception. + is null. + + + + Creates an object that represents an OnCompleted notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The OnCompleted notification. + + + + Represents a type with a single value. This type is often used to denote the successful completion of a void-returning method (C#) or a Sub procedure (Visual Basic). + + + + + Determines whether the specified Unit values is equal to the current Unit. Because Unit has a single value, this always returns true. + + An object to compare to the current Unit value. + Because Unit has a single value, this always returns true. + + + + Determines whether the specified System.Object is equal to the current Unit. + + The System.Object to compare with the current Unit. + true if the specified System.Object is a Unit value; otherwise, false. + + + + Returns the hash code for the current Unit value. + + A hash code for the current Unit value. + + + + Returns a string representation of the current Unit value. + + String representation of the current Unit value. + + + + Determines whether the two specified Unit values are equal. Because Unit has a single value, this always returns true. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns true. + + + + Determines whether the two specified Unit values are not equal. Because Unit has a single value, this always returns false. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns false. + + + + Gets the single unit value. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + 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.. + + + + + Looks up a localized string similar to OnCompleted notification doesn't have a value.. + + + + + Looks up a localized string similar to Disposable has already been assigned.. + + + + + Looks up a localized string similar to Failed to start monitoring system clock changes.. + + + + + Looks up a localized string similar to Heap is empty.. + + + + + Looks up a localized string similar to Reentrancy has been detected.. + + + + + Looks up a localized string similar to Observer has already terminated.. + + + + + Looks up a localized string similar to This scheduler operation has already been awaited.. + + + + diff --git a/packages/Rx-Core.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Core.dll b/packages/Rx-Core.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Core.dll new file mode 100644 index 0000000000000000000000000000000000000000..e338eafbd51637e13648c39a66b6e1c772f9624a GIT binary patch literal 121416 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 + + + System.Reactive.Core + + + + + The System.Reactive.PlatformServices namespace contains interfaces and classes used by the runtime infrastructure of Reactive Extensions. + Those are not intended to be used directly from user code and are subject to change in future releases of the product. + + + + + Provides a set of static methods for subscribing delegates to observables. + + + + + Subscribes to the observable sequence without specifying any handlers. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + IDisposable object used to unsubscribe from the observable sequence. + is null. + + + + Subscribes an element handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or or is null. + + + + Subscribes to the specified source, re-routing synchronous exceptions during invocation of the Subscribe method to the observer's OnError channel. + This method is typically used when writing query operators. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer that will be passed to the observable sequence, and that will be used for exception propagation. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Provides a set of static methods for creating observers. + + + + + Creates an observer from a notification callback. + + The type of the elements received by the observer. + Action that handles a notification. + The observer object that invokes the specified handler using a notification corresponding to each message it receives. + is null. + + + + Creates a notification callback from an observer. + + The type of the elements received by the observer. + Observer object. + The action that forwards its input notification to the underlying observer. + is null. + + + + Creates an observer from the specified OnNext action. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + The observer object implemented using the given actions. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or or is null. + + + + Hides the identity of an observer. + + The type of the elements received by the source observer. + An observer whose identity to hide. + An observer that hides the identity of the specified observer. + is null. + + + + Checks access to the observer for grammar violations. This includes checking for multiple OnError or OnCompleted calls, as well as reentrancy in any of the observer methods. + If a violation is detected, an InvalidOperationException is thrown from the offending observer method call. + + The type of the elements received by the source observer. + The observer whose callback invocations should be checked for grammar violations. + An observer that checks callbacks invocations against the observer grammar and, if the checks pass, forwards those to the specified observer. + is null. + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently from multiple threads. This overload is useful when coordinating access to an observer. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload, passing true for the second parameter. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently. This overload is useful when coordinating access to an observer. + The parameter configures the type of lock used for synchronization. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + If set to true, reentrant observer callbacks will be queued up and get delivered to the observer in a sequential manner. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + When the parameter is set to false, behavior is identical to the overload which uses + a Monitor for synchronization. When the parameter is set to true, an + is used to queue up callbacks to the specified observer if a reentrant call is made. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently by multiple threads, using the specified gate object for use by a Monitor-based lock. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common gate object. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently, using the specified asynchronous lock to protect against concurrent and reentrant access. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common asynchronous lock. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + + + Schedules the invocation of observer methods on the given scheduler. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Scheduler to schedule observer messages on. + Observer whose messages are scheduled on the given scheduler. + or is null. + + + + Schedules the invocation of observer methods on the given synchonization context. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Synchonization context to schedule observer messages on. + Observer whose messages are scheduled on the given synchonization context. + or is null. + + + + Class to create an IObservable<T> instance from a delegate-based implementation of the Subscribe method. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObservable<T> interface. + + + If you don't need a named type to create an observable sequence (i.e. you rather need + an instance rather than a reusable type), use the Observable.Create method to create + an observable sequence with specified subscription behavior. + + The type of the elements in the sequence. + + + + Subscribes the given observer to the observable sequence. + + Observer that will receive notifications from the observable sequence. + Disposable object representing an observer's subscription to the observable sequence. + is null. + + + + Implement this method with the core subscription logic for the observable sequence. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Creates an observable sequence object from the specified subscription function. + + Subscribe method implementation. + is null. + + + + Calls the subscription function that was supplied to the constructor. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Class to create an IObserver<T> instance from delegate-based implementations of the On* methods. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObserver<T> interface. + + This base class enforces the grammar of observers where OnError and OnCompleted are terminal messages. + The type of the elements in the sequence. + + + + Creates a new observer in a non-stopped state. + + + + + Notifies the observer of a new element in the sequence. + + Next element in the sequence. + + + + Implement this method to react to the receival of a new element in the sequence. + + Next element in the sequence. + This method only gets called when the observer hasn't stopped yet. + + + + Notifies the observer that an exception has occurred. + + The error that has occurred. + is null. + + + + Implement this method to react to the occurrence of an exception. + + The error that has occurred. + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Notifies the observer of the end of the sequence. + + + + + Implement this method to react to the end of the sequence. + + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Disposes the observer, causing it to transition to the stopped state. + + + + + Core implementation of IDisposable. + + true if the Dispose call was triggered by the IDisposable.Dispose method; false if it was triggered by the finalizer. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + or or is null. + + + + Creates an observer from the specified OnNext action. + + Observer's OnNext action implementation. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + or is null. + + + + Calls the onNext action. + + Next element in the sequence. + + + + Calls the onError action. + + The error that has occurred. + + + + Calls the onCompleted action. + + + + + This class fuses logic from ObserverBase, AnonymousObserver, and SafeObserver into one class. When an observer + needs to be safeguarded, an instance of this type can be created by SafeObserver.Create when it detects its + input is an AnonymousObserver, which is commonly used by end users when using the Subscribe extension methods + that accept delegates for the On* handlers. By doing the fusion, we make the call stack depth shorter which + helps debugging and some performance. + + + + + Asynchronous lock. + + + + + Queues the action for execution. If the caller acquires the lock and becomes the owner, + the queue is processed. If the lock is already owned, the action is queued and will get + processed by the owner. + + Action to queue for execution. + is null. + + + + Clears the work items in the queue and drops further work being queued. + + + + + (Infrastructure) Concurrency abstraction layer. + + + + + Gets the current CAL. If no CAL has been set yet, it will be initialized to the default. + + + + + (Infrastructure) Concurrency abstraction layer interface. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Queues a method for execution at the specified relative time. + + Method to execute. + State to pass to the method. + Time to execute the method on. + Disposable object that can be used to stop the timer. + + + + Queues a method for periodic execution based on the specified period. + + Method to execute; should be safe for reentrancy. + Period for running the method periodically. + Disposable object that can be used to stop the timer. + + + + Queues a method for execution. + + Method to execute. + State to pass to the method. + Disposable object that can be used to cancel the queued method. + + + + Blocking sleep operation. + + Time to sleep. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Starts a new long-running thread. + + Method to execute. + State to pass to the method. + + + + Gets whether long-running scheduling is supported. + + + + + Provides a set of static properties to access commonly used schedulers. + + + + + Returns a scheduler that represents the original scheduler, without any of its interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable all optimizations for. + Proxy to the original scheduler but without any optimizations enabled. + is null. + + + + Returns a scheduler that represents the original scheduler, without the specified set of interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable the specified optimizations for. + Types of the optimization interfaces that have to be disabled. + Proxy to the original scheduler but without the specified optimizations enabled. + or is null. + + + + Returns a scheduler that wraps the original scheduler, adding exception handling for scheduled actions. + + Type of the exception to check for. + Scheduler to apply an exception filter for. + Handler that's run if an exception is caught. The exception will be rethrown if the handler returns false. + Wrapper around the original scheduler, enforcing exception handling. + or is null. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + The scheduler to run periodic work on. + 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). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + Scheduler to execute the action on. + State passed to the action to be executed. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + Scheduler to execute the action on. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Starts a new stopwatch object by dynamically discovering the scheduler's capabilities. + If the scheduler provides stopwatch functionality, the request will be forwarded to the stopwatch provider implementation. + Otherwise, the stopwatch will be emulated using the scheduler's notion of absolute time. + + Scheduler to obtain a stopwatch for. + New stopwatch object; started at the time of the request. + is null. + The resulting stopwatch object can have non-monotonic behavior. + + + + Returns the ISchedulerLongRunning implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the ISchedulerLongRunning implementation for. + The scheduler's ISchedulerLongRunning implementation if available; null otherwise. + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using in case a stopwatch is required, but use of emulation stopwatch based + on the scheduler's clock is acceptable. Use of this method is recommended for best-effort use of the stopwatch provider + scheduler service, where the caller falls back to not using stopwatches if this facility wasn't found. + + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using the Scheduler.SchedulePeriodic extension methods for IScheduler in case periodic scheduling is required and + emulation of periodic behavior using other scheduler services is desirable. Use of this method is recommended for best-effort + use of the periodic scheduling service, where the caller falls back to not using periodic scheduling if this facility wasn't + found. + + + + + + Normalizes the specified TimeSpan value to a positive value. + + The TimeSpan value to normalize. + The specified TimeSpan value if it is zero or positive; otherwise, TimeSpan.Zero. + + + + Schedules an action to be executed recursively. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in recursive invocation state. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified relative time. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified absolute time. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed after the specified relative due time. + + Scheduler to execute the action on. + Action to execute. + Relative time after which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at the specified absolute due time. + + Scheduler to execute the action on. + Action to execute. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Gets the current time according to the local machine's system clock. + + + + + Gets a scheduler that schedules work immediately on the current thread. + + + + + Gets a scheduler that schedules work as soon as possible on the current thread. + + + + + Gets a scheduler that schedules work on the platform's default scheduler. + + + + + Gets a scheduler that schedules work on the thread pool. + + + + + Gets a scheduler that schedules work on a new thread using default thread creation options. + + + + + Abstract base class for machine-local schedulers, using the local system clock for time-based operations. + + + + + Maximum error ratio for timer drift. We've seen machines with 10s drift on a + daily basis, which is in the order 10E-4, so we allow for extra margin here. + This value is used to calculate early arrival for the long term queue timer + that will reevaluate work for the short term queue. + + Example: -------------------------------...---------------------*-----$ + ^ ^ + | | + early due + 0.999 1.0 + + We also make the gap between early and due at least LONGTOSHORT so we have + enough time to transition work to short term and as a courtesy to the + destination scheduler to manage its queues etc. + + + + + Gate to protect queues and to synchronize scheduling decisions and system clock + change management. + + + + + Long term work queue. Contains work that's due beyond SHORTTERM, computed at the + time of enqueueing. + + + + + Disposable resource for the long term timer that will reevaluate and dispatch the + first item in the long term queue. A serial disposable is used to make "dispose + current and assign new" logic easier. The disposable itself is never disposed. + + + + + Item at the head of the long term queue for which the current long term timer is + running. Used to detect changes in the queue and decide whether we should replace + or can continue using the current timer (because no earlier long term work was + added to the queue). + + + + + Short term work queue. Contains work that's due soon, computed at the time of + enqueueing or upon reevaluation of the long term queue causing migration of work + items. This queue is kept in order to be able to relocate short term items back + to the long term queue in case a system clock change occurs. + + + + + Set of disposable handles to all of the current short term work Schedule calls, + allowing those to be cancelled upon a system clock change. + + + + + Threshold where an item is considered to be short term work or gets moved from + long term to short term. + + + + + Minimum threshold for the long term timer to fire before the queue is reevaluated + for short term work. This value is chosen to be less than SHORTTERM in order to + ensure the timer fires and has work to transition to the short term queue. + + + + + Threshold used to determine when a short term timer has fired too early compared + to the absolute due time. This provides a last chance protection against early + completion of scheduled work, which can happen in case of time adjustment in the + operating system (cf. GetSystemTimeAdjustment). + + + + + Enqueues absolute time scheduled work in the timer queue or the short term work list. + + Scheduler to run the work on. Typically "this" from the caller's perspective (LocalScheduler.Schedule), but parameter kept because we have a single (static) timer queue across all of Rx local schedulers. + State to pass to the action. + Absolute time to run the work on. The timer queue is responsible to execute the work close to the specified time, also accounting for system clock changes. + Action to run, potentially recursing into the scheduler. + Disposable object to prevent the work from running. + + + + Schedule work that's due in the short term. This leads to relative scheduling calls to the + underlying scheduler for short TimeSpan values. If the system clock changes in the meantime, + the short term work is attempted to be cancelled and reevaluated. + + Work item to schedule in the short term. The caller is responsible to determine the work is indeed short term. + + + + Callback to process the next short term work item. + + Recursive scheduler supplied by the underlying scheduler. + Disposable used to identify the work the timer was triggered for (see code for usage). + Empty disposable. Recursive work cancellation is wired through the original WorkItem. + + + + Schedule work that's due on the long term. This leads to the work being queued up for + eventual transitioning to the short term work list. + + Work item to schedule on the long term. The caller is responsible to determine the work is indeed long term. + + + + Updates the long term timer which is responsible to transition work from the head of the + long term queue to the short term work list. + + Should be called under the scheduler lock. + + + + Evaluates the long term queue, transitioning short term work to the short term list, + and adjusting the new long term processing timer accordingly. + + Ignored. + + + + Callback invoked when a system clock change is observed in order to adjust and reevaluate + the internal scheduling queues. + + Currently not used. + Currently not used. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + Platform-specific scheduler implementations should reimplement IStopwatchProvider to provide a more + efficient IStopwatch implementation (if available). + + + + + Discovers scheduler services by interface type. The base class implementation returns + requested services for each scheduler interface implemented by the derived class. For + more control over service discovery, derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the scheduler's notion of current time. + + + + + Represents a work item in the absolute time scheduler. + + + This type is very similar to ScheduledItem, but we need a different Invoke signature to allow customization + of the target scheduler (e.g. when called in a recursive scheduling context, see ExecuteNextShortTermWorkItem). + + + + + Represents a work item that closes over scheduler invocation state. Subtyping is + used to have a common type for the scheduler queues. + + + + + Represents an object that schedules units of work on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the current thread scheduler. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Represents an object that schedules units of work to run immediately on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the immediate scheduler. + + + + + Abstract base class for scheduled work items. + + Absolute time representation type. + + + + Creates a new scheduled work item to run at the specified time. + + Absolute time at which the work item has to be executed. + Comparer used to compare work items based on their scheduled time. + is null. + + + + Invokes the work item. + + + + + Implement this method to perform the work item invocation, returning a disposable object for deep cancellation. + + Disposable object used to cancel the work item and/or derived work items. + + + + Compares the work item with another work item based on absolute time values. + + Work item to compare the current work item to. + Relative ordering between this and the specified work item. + The inequality operators are overloaded to provide results consistent with the IComparable implementation. Equality operators implement traditional reference equality semantics. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before or at the same of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after or at the same time of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are equal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are equal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are inequal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are inequal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether a ScheduledItem<TAbsolute> object is equal to the specified object. + + The object to compare to the current ScheduledItem<TAbsolute> object. + true if the obj parameter is a ScheduledItem<TAbsolute> object and is equal to the current ScheduledItem<TAbsolute> object; otherwise, false. + + + + Returns the hash code for the current ScheduledItem<TAbsolute> object. + + A 32-bit signed integer hash code. + + + + Cancels the work item by disposing the resource returned by InvokeCore as soon as possible. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Gets whether the work item has received a cancellation request. + + + + + Represents a scheduled work item based on the materialization of an IScheduler.Schedule method call. + + Absolute time representation type. + Type of the state passed to the scheduled action. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + Comparer used to compare work items based on their scheduled time. + or or is null. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + or is null. + + + + Invokes the scheduled action with the supplied recursive scheduler and state. + + Cancellation resource returned by the scheduled action. + + + + Efficient scheduler queue that maintains scheduled items sorted by absolute time. + + Absolute time representation type. + This type is not thread safe; users should ensure proper synchronization. + + + + Creates a new scheduler queue with a default initial capacity. + + + + + Creats a new scheduler queue with the specified initial capacity. + + Initial capacity of the scheduler queue. + is less than zero. + + + + Enqueues the specified work item to be scheduled. + + Work item to be scheduled. + + + + Removes the specified work item from the scheduler queue. + + Work item to be removed from the scheduler queue. + true if the item was found; false otherwise. + + + + Dequeues the next work item from the scheduler queue. + + Next work item in the scheduler queue (removed). + + + + Peeks the next work item in the scheduler queue. + + Next work item in the scheduler queue (not removed). + + + + Gets the number of scheduled items in the scheduler queue. + + + + + Provides basic synchronization and scheduling services for observable sequences. + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified scheduler. + In order to invoke observer callbacks on the specified scheduler, e.g. to offload callback processing to a dedicated thread, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified synchronization context. + In order to invoke observer callbacks on the specified synchronization context, e.g. to post callbacks to a UI thread represented by the synchronization context, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + + + Wraps the source sequence in order to ensure observer callbacks are properly serialized. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + + + Wraps the source sequence in order to ensure observer callbacks are synchronized using the specified gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Base class for implementation of query operators, providing performance benefits over the use of Observable.Create. + + Type of the resulting sequence's elements. + + + + Interface with variance annotation; allows for better type checking when detecting capabilities in SubscribeSafe. + + Type of the resulting sequence's elements. + + + + Publicly visible Subscribe method. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + IDisposable to cancel the subscription. This causes the underlying sink to be notified of unsubscription, causing it to prevent further messages from being sent to the observer. + + + + Core implementation of the query operator, called upon a new subscription to the producer object. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + The subscription disposable object returned from the Run call, passed in such that it can be forwarded to the sink, allowing it to dispose the subscription upon sending a final message (or prematurely for other reasons). + Callback to communicate the sink object to the subscriber, allowing consumers to tunnel a Dispose call into the sink, which can stop the processing. + Disposable representing all the resources and/or subscriptions the operator uses to process events. + The observer passed in to this method is not protected using auto-detach behavior upon an OnError or OnCompleted call. The implementation must ensure proper resource disposal and enforce the message grammar. + + + + Base class for implementation of query operators, providing a lightweight sink that can be disposed to mute the outgoing observer. + + Type of the resulting sequence's elements. + Implementations of sinks are responsible to enforce the message grammar on the associated observer. Upon sending a terminal message, a pairing Dispose call should be made to trigger cancellation of related resources and to mute the outgoing observer. + + + + Represents an object that schedules units of work on a provided . + + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + is null. + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + Configures whether scheduling always posts to the synchronization context, regardless whether the caller is on the same synchronization context. + is null. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Represents an object that schedules units of work on the platform's default scheduler. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a System.Threading.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. + + + + Schedules a periodic piece of work, using a System.Threading.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 less than TimeSpan.Zero. + is null. + + + + Discovers scheduler services by interface type. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the singleton instance of the default scheduler. + + + + + Represents an Action-based disposable. + + + + + Constructs a new disposable with the given action used for disposal. + + Disposal action which will be run upon calling Dispose. + + + + Calls the disposal action if and only if the current instance hasn't been disposed yet. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that can be checked for disposal status. + + + + + Initializes a new instance of the class. + + + + + Sets the status to disposed, which can be observer through the property. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a group of disposable resources that are disposed together. + + + + + Initializes a new instance of the class with no disposables contained by it initially. + + + + + Initializes a new instance of the class with the specified number of disposables. + + The number of disposables that the new CompositeDisposable can initially store. + is less than zero. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed. + + Disposable to add. + is null. + + + + Removes and disposes the first occurrence of a disposable from the CompositeDisposable. + + Disposable to remove. + true if found; false otherwise. + is null. + + + + Disposes all disposables in the group and removes them from the group. + + + + + Removes and disposes all disposables from the CompositeDisposable, but does not dispose the CompositeDisposable. + + + + + Determines whether the CompositeDisposable contains a specific disposable. + + Disposable to search for. + true if the disposable was found; otherwise, false. + is null. + + + + Copies the disposables contained in the CompositeDisposable to an array, starting at a particular array index. + + Array to copy the contained disposables to. + Target index at which to copy the first disposable of the group. + is null. + is less than zero. -or - is larger than or equal to the array length. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Gets the number of disposables contained in the CompositeDisposable. + + + + + Always returns false. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be posted to the specified . + + + + + Initializes a new instance of the class that uses the specified on which to dispose the specified disposable resource. + + Context to perform disposal on. + Disposable whose Dispose operation to run on the given synchronization context. + or is null. + + + + Disposes the underlying disposable on the provided . + + + + + Gets the provided . + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable that does nothing on disposal. + + + + + Singleton default disposable. + + + + + Does nothing. + + + + + Provides a set of static methods for creating Disposables. + + + + + Creates a disposable object that invokes the specified action when disposed. + + Action to run during the first call to . The action is guaranteed to be run at most once. + The disposable object that runs the given action upon disposal. + is null. + + + + Gets the disposable that does nothing when disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be swapped for another disposable resource. + + + + + Initializes a new instance of the class with no current underlying disposable. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + If the MutableDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. + + + + Represents a disposable resource that only disposes its underlying disposable resource when all dependent disposable objects have been disposed. + + + + + Initializes a new instance of the class with the specified disposable. + + Underlying disposable. + is null. + + + + Returns a dependent disposable that when disposed decreases the refcount on the underlying disposable. + + A dependent disposable contributing to the reference count that manages the underlying disposable's lifetime. + + + + Disposes the underlying disposable only when all dependent disposables have been disposed. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be scheduled on the specified . + + + + + Initializes a new instance of the class that uses an on which to dispose the disposable. + + Scheduler where the disposable resource will be disposed on. + Disposable resource to dispose on the given scheduler. + or is null. + + + + Disposes the wrapped disposable on the provided scheduler. + + + + + Gets the scheduler where the disposable resource will be disposed on. + + + + + Gets the underlying disposable. After disposal, the result is undefined. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be replaced by another disposable resource, causing automatic disposal of the previous underlying disposable resource. + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. + + If the SerialDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. Assigning this property disposes the previous disposable object. + + + + Represents a disposable resource which only allows a single assignment of its underlying disposable resource. + If an underlying disposable resource has already been set, future attempts to set the underlying disposable resource will throw an . + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + Thrown if the SingleAssignmentDisposable has already been assigned to. + + + + (Infrastructure) Services to rethrow exceptions. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Rethrows the specified exception. + + Exception to rethrow. + + + + (Infrastructure) Provides access to the host's lifecycle management services. + + + + + Adds a reference to the host lifecycle manager, causing it to be sending notifications. + + + + + Removes a reference to the host lifecycle manager, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Event that gets raised when the host suspends the application. + + + + + Event that gets raised when the host resumes the application. + + + + + (Infrastructure) Provides notifications about the host's lifecycle events. + + + + + Event that gets raised when the host suspends. + + + + + Event that gets raised when the host resumes. + + + + + (Infrastructure) Event arguments for host suspension events. + + + + + (Infrastructure) Event arguments for host resumption events. + + + + + (Infrastructure) Interface for enlightenment providers. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Gets the current enlightenment provider. If none is loaded yet, accessing this property triggers provider resolution. + + + This member is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Provides access to local system clock services. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Adds a reference to the system clock monitor, causing it to be sending notifications. + + Thrown when the system doesn't support sending clock change notifications. + + + + Removes a reference to the system clock monitor, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Gets the local system clock time. + + + + + Event that gets raised when a system clock change is detected, if there's any interest as indicated by AddRef calls. + + + + + (Infrastructure) Provides access to the local system clock. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Gets the current time. + + + + + (Infrastructure) Provides a mechanism to notify local schedulers about system clock changes. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Event that gets raised when a system clock change is detected. + + + + + (Infrastructure) Event arguments for system clock change notifications. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Creates a new system clock notification object with unknown old and new times. + + + + + Creates a new system clock notification object with the specified old and new times. + + Time before the system clock changed, or DateTimeOffset.MinValue if not known. + Time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + Gets the time before the system clock changed, or DateTimeOffset.MinValue if not known. + + + + + Gets the time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + + (Infrastructure) Provides access to the local system clock. + + + + + Gets the current time. + + + + + (Infrastructure) Monitors for system clock changes based on a periodic timer. + + + + + Creates a new monitor for system clock changes with the specified polling frequency. + + Polling frequency for system clock changes. + + + + Event that gets raised when a system clock change is detected. + + + + + Indicates the type of a notification. + + + + + Represents an OnNext notification. + + + + + Represents an OnError notification. + + + + + Represents an OnCompleted notification. + + + + + Represents a notification to an observer. + + The type of the elements received by the observer. + + + + Default constructor used by derived types. + + + + + Determines whether the current Notification<T> object has the same observer message payload as a specified Notification<T> value. + + An object to compare to the current Notification<T> object. + true if both Notification<T> objects have the same observer message payload; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have the same observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has the same observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have a different observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has a different observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent a different observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the specified System.Object is equal to the current Notification<T>. + + The System.Object to compare with the current Notification<T>. + true if the specified System.Object is equal to the current Notification<T>; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + The type of the result returned from the observer's notification handlers. + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + The type of the result returned from the notification handler delegates. + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns an observable sequence with a single notification, using the immediate scheduler. + + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns an observable sequence with a single notification. + + Scheduler to send out the notification calls on. + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns the value of an OnNext notification or throws an exception. + + + + + Returns a value that indicates whether the notification has a value. + + + + + Returns the exception of an OnError notification or returns null. + + + + + Gets the kind of notification that is represented. + + + + + Represents an OnNext notification to an observer. + + + + + Constructs a notification of a new value. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and a specified object are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns the value of an OnNext notification. + + + + + Returns null. + + + + + Returns true. + + + + + Returns NotificationKind.OnNext. + + + + + Represents an OnError notification to an observer. + + + + + Constructs a notification of an exception. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws the exception. + + + + + Returns the exception. + + + + + Returns false. + + + + + Returns NotificationKind.OnError. + + + + + Represents an OnCompleted notification to an observer. + + + + + Constructs a notification of the end of a sequence. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws an InvalidOperationException. + + + + + Returns null. + + + + + Returns false. + + + + + Returns NotificationKind.OnCompleted. + + + + + Provides a set of static methods for constructing notifications. + + + + + Creates an object that represents an OnNext notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The value contained in the notification. + The OnNext notification containing the value. + + + + Creates an object that represents an OnError notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The exception contained in the notification. + The OnError notification containing the exception. + is null. + + + + Creates an object that represents an OnCompleted notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The OnCompleted notification. + + + + Represents a type with a single value. This type is often used to denote the successful completion of a void-returning method (C#) or a Sub procedure (Visual Basic). + + + + + Determines whether the specified Unit values is equal to the current Unit. Because Unit has a single value, this always returns true. + + An object to compare to the current Unit value. + Because Unit has a single value, this always returns true. + + + + Determines whether the specified System.Object is equal to the current Unit. + + The System.Object to compare with the current Unit. + true if the specified System.Object is a Unit value; otherwise, false. + + + + Returns the hash code for the current Unit value. + + A hash code for the current Unit value. + + + + Returns a string representation of the current Unit value. + + String representation of the current Unit value. + + + + Determines whether the two specified Unit values are equal. Because Unit has a single value, this always returns true. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns true. + + + + Determines whether the two specified Unit values are not equal. Because Unit has a single value, this always returns false. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns false. + + + + Gets the single unit value. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + 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.. + + + + + Looks up a localized string similar to OnCompleted notification doesn't have a value.. + + + + + Looks up a localized string similar to Disposable has already been assigned.. + + + + + Looks up a localized string similar to Failed to start monitoring system clock changes.. + + + + + Looks up a localized string similar to Heap is empty.. + + + + + Looks up a localized string similar to Reentrancy has been detected.. + + + + + Looks up a localized string similar to Observer has already terminated.. + + + + + Looks up a localized string similar to This scheduler operation has already been awaited.. + + + + diff --git a/packages/Rx-Core.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Core.dll b/packages/Rx-Core.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Core.dll new file mode 100644 index 0000000000000000000000000000000000000000..a77e6775dde13dbd3fd859c482c86e455fe84891 GIT binary patch literal 104016 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 + + + System.Reactive.Core + + + + + The System.Reactive.PlatformServices namespace contains interfaces and classes used by the runtime infrastructure of Reactive Extensions. + Those are not intended to be used directly from user code and are subject to change in future releases of the product. + + + + + Provides a set of static methods for subscribing delegates to observables. + + + + + Subscribes to the observable sequence without specifying any handlers. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + IDisposable object used to unsubscribe from the observable sequence. + is null. + + + + Subscribes an element handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or or is null. + + + + Subscribes an observer to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer to subscribe to the sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or is null. + + + + Subscribes to the observable sequence without specifying any handlers, using a CancellationToken to support unsubscription. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + CancellationToken that can be signaled to unsubscribe from the source sequence. + is null. + + + + Subscribes an element handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or or is null. + + + + Subscribes to the specified source, re-routing synchronous exceptions during invocation of the Subscribe method to the observer's OnError channel. + This method is typically used when writing query operators. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer that will be passed to the observable sequence, and that will be used for exception propagation. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Provides a set of static methods for creating observers. + + + + + Creates an observer from a notification callback. + + The type of the elements received by the observer. + Action that handles a notification. + The observer object that invokes the specified handler using a notification corresponding to each message it receives. + is null. + + + + Creates a notification callback from an observer. + + The type of the elements received by the observer. + Observer object. + The action that forwards its input notification to the underlying observer. + is null. + + + + Creates an observer from the specified OnNext action. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + The observer object implemented using the given actions. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or or is null. + + + + Hides the identity of an observer. + + The type of the elements received by the source observer. + An observer whose identity to hide. + An observer that hides the identity of the specified observer. + is null. + + + + Checks access to the observer for grammar violations. This includes checking for multiple OnError or OnCompleted calls, as well as reentrancy in any of the observer methods. + If a violation is detected, an InvalidOperationException is thrown from the offending observer method call. + + The type of the elements received by the source observer. + The observer whose callback invocations should be checked for grammar violations. + An observer that checks callbacks invocations against the observer grammar and, if the checks pass, forwards those to the specified observer. + is null. + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently from multiple threads. This overload is useful when coordinating access to an observer. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload, passing true for the second parameter. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently. This overload is useful when coordinating access to an observer. + The parameter configures the type of lock used for synchronization. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + If set to true, reentrant observer callbacks will be queued up and get delivered to the observer in a sequential manner. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + When the parameter is set to false, behavior is identical to the overload which uses + a Monitor for synchronization. When the parameter is set to true, an + is used to queue up callbacks to the specified observer if a reentrant call is made. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently by multiple threads, using the specified gate object for use by a Monitor-based lock. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common gate object. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently, using the specified asynchronous lock to protect against concurrent and reentrant access. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common asynchronous lock. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + + + Schedules the invocation of observer methods on the given scheduler. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Scheduler to schedule observer messages on. + Observer whose messages are scheduled on the given scheduler. + or is null. + + + + Schedules the invocation of observer methods on the given synchonization context. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Synchonization context to schedule observer messages on. + Observer whose messages are scheduled on the given synchonization context. + or is null. + + + + Class to create an IObservable<T> instance from a delegate-based implementation of the Subscribe method. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObservable<T> interface. + + + If you don't need a named type to create an observable sequence (i.e. you rather need + an instance rather than a reusable type), use the Observable.Create method to create + an observable sequence with specified subscription behavior. + + The type of the elements in the sequence. + + + + Subscribes the given observer to the observable sequence. + + Observer that will receive notifications from the observable sequence. + Disposable object representing an observer's subscription to the observable sequence. + is null. + + + + Implement this method with the core subscription logic for the observable sequence. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Creates an observable sequence object from the specified subscription function. + + Subscribe method implementation. + is null. + + + + Calls the subscription function that was supplied to the constructor. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Class to create an IObserver<T> instance from delegate-based implementations of the On* methods. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObserver<T> interface. + + This base class enforces the grammar of observers where OnError and OnCompleted are terminal messages. + The type of the elements in the sequence. + + + + Creates a new observer in a non-stopped state. + + + + + Notifies the observer of a new element in the sequence. + + Next element in the sequence. + + + + Implement this method to react to the receival of a new element in the sequence. + + Next element in the sequence. + This method only gets called when the observer hasn't stopped yet. + + + + Notifies the observer that an exception has occurred. + + The error that has occurred. + is null. + + + + Implement this method to react to the occurrence of an exception. + + The error that has occurred. + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Notifies the observer of the end of the sequence. + + + + + Implement this method to react to the end of the sequence. + + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Disposes the observer, causing it to transition to the stopped state. + + + + + Core implementation of IDisposable. + + true if the Dispose call was triggered by the IDisposable.Dispose method; false if it was triggered by the finalizer. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + or or is null. + + + + Creates an observer from the specified OnNext action. + + Observer's OnNext action implementation. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + or is null. + + + + Calls the onNext action. + + Next element in the sequence. + + + + Calls the onError action. + + The error that has occurred. + + + + Calls the onCompleted action. + + + + + This class fuses logic from ObserverBase, AnonymousObserver, and SafeObserver into one class. When an observer + needs to be safeguarded, an instance of this type can be created by SafeObserver.Create when it detects its + input is an AnonymousObserver, which is commonly used by end users when using the Subscribe extension methods + that accept delegates for the On* handlers. By doing the fusion, we make the call stack depth shorter which + helps debugging and some performance. + + + + + Asynchronous lock. + + + + + Queues the action for execution. If the caller acquires the lock and becomes the owner, + the queue is processed. If the lock is already owned, the action is queued and will get + processed by the owner. + + Action to queue for execution. + is null. + + + + Clears the work items in the queue and drops further work being queued. + + + + + (Infrastructure) Concurrency abstraction layer. + + + + + Gets the current CAL. If no CAL has been set yet, it will be initialized to the default. + + + + + (Infrastructure) Concurrency abstraction layer interface. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Queues a method for execution at the specified relative time. + + Method to execute. + State to pass to the method. + Time to execute the method on. + Disposable object that can be used to stop the timer. + + + + Queues a method for periodic execution based on the specified period. + + Method to execute; should be safe for reentrancy. + Period for running the method periodically. + Disposable object that can be used to stop the timer. + + + + Queues a method for execution. + + Method to execute. + State to pass to the method. + Disposable object that can be used to cancel the queued method. + + + + Blocking sleep operation. + + Time to sleep. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Starts a new long-running thread. + + Method to execute. + State to pass to the method. + + + + Gets whether long-running scheduling is supported. + + + + + Provides a set of static properties to access commonly used schedulers. + + + + + Returns a scheduler that represents the original scheduler, without any of its interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable all optimizations for. + Proxy to the original scheduler but without any optimizations enabled. + is null. + + + + Returns a scheduler that represents the original scheduler, without the specified set of interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable the specified optimizations for. + Types of the optimization interfaces that have to be disabled. + Proxy to the original scheduler but without the specified optimizations enabled. + or is null. + + + + Returns a scheduler that wraps the original scheduler, adding exception handling for scheduled actions. + + Type of the exception to check for. + Scheduler to apply an exception filter for. + Handler that's run if an exception is caught. The exception will be rethrown if the handler returns false. + Wrapper around the original scheduler, enforcing exception handling. + or is null. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + The scheduler to run periodic work on. + 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). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + Scheduler to execute the action on. + State passed to the action to be executed. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + Scheduler to execute the action on. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Starts a new stopwatch object by dynamically discovering the scheduler's capabilities. + If the scheduler provides stopwatch functionality, the request will be forwarded to the stopwatch provider implementation. + Otherwise, the stopwatch will be emulated using the scheduler's notion of absolute time. + + Scheduler to obtain a stopwatch for. + New stopwatch object; started at the time of the request. + is null. + The resulting stopwatch object can have non-monotonic behavior. + + + + Returns the ISchedulerLongRunning implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the ISchedulerLongRunning implementation for. + The scheduler's ISchedulerLongRunning implementation if available; null otherwise. + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using in case a stopwatch is required, but use of emulation stopwatch based + on the scheduler's clock is acceptable. Use of this method is recommended for best-effort use of the stopwatch provider + scheduler service, where the caller falls back to not using stopwatches if this facility wasn't found. + + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using the Scheduler.SchedulePeriodic extension methods for IScheduler in case periodic scheduling is required and + emulation of periodic behavior using other scheduler services is desirable. Use of this method is recommended for best-effort + use of the periodic scheduling service, where the caller falls back to not using periodic scheduling if this facility wasn't + found. + + + + + + Normalizes the specified TimeSpan value to a positive value. + + The TimeSpan value to normalize. + The specified TimeSpan value if it is zero or positive; otherwise, TimeSpan.Zero. + + + + Schedules an action to be executed recursively. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in recursive invocation state. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified relative time. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified absolute time. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed after the specified relative due time. + + Scheduler to execute the action on. + Action to execute. + Relative time after which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at the specified absolute due time. + + Scheduler to execute the action on. + Action to execute. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Gets the current time according to the local machine's system clock. + + + + + Gets a scheduler that schedules work immediately on the current thread. + + + + + Gets a scheduler that schedules work as soon as possible on the current thread. + + + + + Gets a scheduler that schedules work on the platform's default scheduler. + + + + + Gets a scheduler that schedules work on the thread pool. + + + + + Gets a scheduler that schedules work on a new thread using default thread creation options. + + + + + Gets a scheduler that schedules work on Task Parallel Library (TPL) task pool using the default TaskScheduler. + + + + + Abstract base class for machine-local schedulers, using the local system clock for time-based operations. + + + + + Maximum error ratio for timer drift. We've seen machines with 10s drift on a + daily basis, which is in the order 10E-4, so we allow for extra margin here. + This value is used to calculate early arrival for the long term queue timer + that will reevaluate work for the short term queue. + + Example: -------------------------------...---------------------*-----$ + ^ ^ + | | + early due + 0.999 1.0 + + We also make the gap between early and due at least LONGTOSHORT so we have + enough time to transition work to short term and as a courtesy to the + destination scheduler to manage its queues etc. + + + + + Gate to protect queues and to synchronize scheduling decisions and system clock + change management. + + + + + Long term work queue. Contains work that's due beyond SHORTTERM, computed at the + time of enqueueing. + + + + + Disposable resource for the long term timer that will reevaluate and dispatch the + first item in the long term queue. A serial disposable is used to make "dispose + current and assign new" logic easier. The disposable itself is never disposed. + + + + + Item at the head of the long term queue for which the current long term timer is + running. Used to detect changes in the queue and decide whether we should replace + or can continue using the current timer (because no earlier long term work was + added to the queue). + + + + + Short term work queue. Contains work that's due soon, computed at the time of + enqueueing or upon reevaluation of the long term queue causing migration of work + items. This queue is kept in order to be able to relocate short term items back + to the long term queue in case a system clock change occurs. + + + + + Set of disposable handles to all of the current short term work Schedule calls, + allowing those to be cancelled upon a system clock change. + + + + + Threshold where an item is considered to be short term work or gets moved from + long term to short term. + + + + + Minimum threshold for the long term timer to fire before the queue is reevaluated + for short term work. This value is chosen to be less than SHORTTERM in order to + ensure the timer fires and has work to transition to the short term queue. + + + + + Threshold used to determine when a short term timer has fired too early compared + to the absolute due time. This provides a last chance protection against early + completion of scheduled work, which can happen in case of time adjustment in the + operating system (cf. GetSystemTimeAdjustment). + + + + + Enqueues absolute time scheduled work in the timer queue or the short term work list. + + Scheduler to run the work on. Typically "this" from the caller's perspective (LocalScheduler.Schedule), but parameter kept because we have a single (static) timer queue across all of Rx local schedulers. + State to pass to the action. + Absolute time to run the work on. The timer queue is responsible to execute the work close to the specified time, also accounting for system clock changes. + Action to run, potentially recursing into the scheduler. + Disposable object to prevent the work from running. + + + + Schedule work that's due in the short term. This leads to relative scheduling calls to the + underlying scheduler for short TimeSpan values. If the system clock changes in the meantime, + the short term work is attempted to be cancelled and reevaluated. + + Work item to schedule in the short term. The caller is responsible to determine the work is indeed short term. + + + + Callback to process the next short term work item. + + Recursive scheduler supplied by the underlying scheduler. + Disposable used to identify the work the timer was triggered for (see code for usage). + Empty disposable. Recursive work cancellation is wired through the original WorkItem. + + + + Schedule work that's due on the long term. This leads to the work being queued up for + eventual transitioning to the short term work list. + + Work item to schedule on the long term. The caller is responsible to determine the work is indeed long term. + + + + Updates the long term timer which is responsible to transition work from the head of the + long term queue to the short term work list. + + Should be called under the scheduler lock. + + + + Evaluates the long term queue, transitioning short term work to the short term list, + and adjusting the new long term processing timer accordingly. + + Ignored. + + + + Callback invoked when a system clock change is observed in order to adjust and reevaluate + the internal scheduling queues. + + Currently not used. + Currently not used. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + Platform-specific scheduler implementations should reimplement IStopwatchProvider to provide a more + efficient IStopwatch implementation (if available). + + + + + Discovers scheduler services by interface type. The base class implementation returns + requested services for each scheduler interface implemented by the derived class. For + more control over service discovery, derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the scheduler's notion of current time. + + + + + Represents a work item in the absolute time scheduler. + + + This type is very similar to ScheduledItem, but we need a different Invoke signature to allow customization + of the target scheduler (e.g. when called in a recursive scheduling context, see ExecuteNextShortTermWorkItem). + + + + + Represents a work item that closes over scheduler invocation state. Subtyping is + used to have a common type for the scheduler queues. + + + + + Represents an object that schedules units of work on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the current thread scheduler. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Represents an object that schedules units of work to run immediately on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the immediate scheduler. + + + + + Abstract base class for scheduled work items. + + Absolute time representation type. + + + + Creates a new scheduled work item to run at the specified time. + + Absolute time at which the work item has to be executed. + Comparer used to compare work items based on their scheduled time. + is null. + + + + Invokes the work item. + + + + + Implement this method to perform the work item invocation, returning a disposable object for deep cancellation. + + Disposable object used to cancel the work item and/or derived work items. + + + + Compares the work item with another work item based on absolute time values. + + Work item to compare the current work item to. + Relative ordering between this and the specified work item. + The inequality operators are overloaded to provide results consistent with the IComparable implementation. Equality operators implement traditional reference equality semantics. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before or at the same of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after or at the same time of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are equal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are equal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are inequal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are inequal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether a ScheduledItem<TAbsolute> object is equal to the specified object. + + The object to compare to the current ScheduledItem<TAbsolute> object. + true if the obj parameter is a ScheduledItem<TAbsolute> object and is equal to the current ScheduledItem<TAbsolute> object; otherwise, false. + + + + Returns the hash code for the current ScheduledItem<TAbsolute> object. + + A 32-bit signed integer hash code. + + + + Cancels the work item by disposing the resource returned by InvokeCore as soon as possible. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Gets whether the work item has received a cancellation request. + + + + + Represents a scheduled work item based on the materialization of an IScheduler.Schedule method call. + + Absolute time representation type. + Type of the state passed to the scheduled action. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + Comparer used to compare work items based on their scheduled time. + or or is null. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + or is null. + + + + Invokes the scheduled action with the supplied recursive scheduler and state. + + Cancellation resource returned by the scheduled action. + + + + Efficient scheduler queue that maintains scheduled items sorted by absolute time. + + Absolute time representation type. + This type is not thread safe; users should ensure proper synchronization. + + + + Creates a new scheduler queue with a default initial capacity. + + + + + Creats a new scheduler queue with the specified initial capacity. + + Initial capacity of the scheduler queue. + is less than zero. + + + + Enqueues the specified work item to be scheduled. + + Work item to be scheduled. + + + + Removes the specified work item from the scheduler queue. + + Work item to be removed from the scheduler queue. + true if the item was found; false otherwise. + + + + Dequeues the next work item from the scheduler queue. + + Next work item in the scheduler queue (removed). + + + + Peeks the next work item in the scheduler queue. + + Next work item in the scheduler queue (not removed). + + + + Gets the number of scheduled items in the scheduler queue. + + + + + Provides basic synchronization and scheduling services for observable sequences. + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified scheduler. + In order to invoke observer callbacks on the specified scheduler, e.g. to offload callback processing to a dedicated thread, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified synchronization context. + In order to invoke observer callbacks on the specified synchronization context, e.g. to post callbacks to a UI thread represented by the synchronization context, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + + + Wraps the source sequence in order to ensure observer callbacks are properly serialized. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + + + Wraps the source sequence in order to ensure observer callbacks are synchronized using the specified gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Base class for implementation of query operators, providing performance benefits over the use of Observable.Create. + + Type of the resulting sequence's elements. + + + + Interface with variance annotation; allows for better type checking when detecting capabilities in SubscribeSafe. + + Type of the resulting sequence's elements. + + + + Publicly visible Subscribe method. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + IDisposable to cancel the subscription. This causes the underlying sink to be notified of unsubscription, causing it to prevent further messages from being sent to the observer. + + + + Core implementation of the query operator, called upon a new subscription to the producer object. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + The subscription disposable object returned from the Run call, passed in such that it can be forwarded to the sink, allowing it to dispose the subscription upon sending a final message (or prematurely for other reasons). + Callback to communicate the sink object to the subscriber, allowing consumers to tunnel a Dispose call into the sink, which can stop the processing. + Disposable representing all the resources and/or subscriptions the operator uses to process events. + The observer passed in to this method is not protected using auto-detach behavior upon an OnError or OnCompleted call. The implementation must ensure proper resource disposal and enforce the message grammar. + + + + Base class for implementation of query operators, providing a lightweight sink that can be disposed to mute the outgoing observer. + + Type of the resulting sequence's elements. + Implementations of sinks are responsible to enforce the message grammar on the associated observer. Upon sending a terminal message, a pairing Dispose call should be made to trigger cancellation of related resources and to mute the outgoing observer. + + + + Represents an object that schedules units of work on a provided . + + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + is null. + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + Configures whether scheduling always posts to the synchronization context, regardless whether the caller is on the same synchronization context. + is null. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Represents an object that schedules units of work on the platform's default scheduler. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a System.Threading.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. + + + + Schedules a periodic piece of work, using a System.Threading.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 less than TimeSpan.Zero. + is null. + + + + Discovers scheduler services by interface type. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the singleton instance of the default scheduler. + + + + + Represents an Action-based disposable. + + + + + Constructs a new disposable with the given action used for disposal. + + Disposal action which will be run upon calling Dispose. + + + + Calls the disposal action if and only if the current instance hasn't been disposed yet. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that can be checked for disposal status. + + + + + Initializes a new instance of the class. + + + + + Sets the status to disposed, which can be observer through the property. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that has an associated that will be set to the cancellation requested state upon disposal. + + + + + Initializes a new instance of the class that uses an existing . + + used for cancellation. + is null. + + + + Initializes a new instance of the class that uses a new . + + + + + Cancels the underlying . + + + + + Gets the used by this CancellationDisposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a group of disposable resources that are disposed together. + + + + + Initializes a new instance of the class with no disposables contained by it initially. + + + + + Initializes a new instance of the class with the specified number of disposables. + + The number of disposables that the new CompositeDisposable can initially store. + is less than zero. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed. + + Disposable to add. + is null. + + + + Removes and disposes the first occurrence of a disposable from the CompositeDisposable. + + Disposable to remove. + true if found; false otherwise. + is null. + + + + Disposes all disposables in the group and removes them from the group. + + + + + Removes and disposes all disposables from the CompositeDisposable, but does not dispose the CompositeDisposable. + + + + + Determines whether the CompositeDisposable contains a specific disposable. + + Disposable to search for. + true if the disposable was found; otherwise, false. + is null. + + + + Copies the disposables contained in the CompositeDisposable to an array, starting at a particular array index. + + Array to copy the contained disposables to. + Target index at which to copy the first disposable of the group. + is null. + is less than zero. -or - is larger than or equal to the array length. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Gets the number of disposables contained in the CompositeDisposable. + + + + + Always returns false. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be posted to the specified . + + + + + Initializes a new instance of the class that uses the specified on which to dispose the specified disposable resource. + + Context to perform disposal on. + Disposable whose Dispose operation to run on the given synchronization context. + or is null. + + + + Disposes the underlying disposable on the provided . + + + + + Gets the provided . + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable that does nothing on disposal. + + + + + Singleton default disposable. + + + + + Does nothing. + + + + + Provides a set of static methods for creating Disposables. + + + + + Creates a disposable object that invokes the specified action when disposed. + + Action to run during the first call to . The action is guaranteed to be run at most once. + The disposable object that runs the given action upon disposal. + is null. + + + + Gets the disposable that does nothing when disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be swapped for another disposable resource. + + + + + Initializes a new instance of the class with no current underlying disposable. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + If the MutableDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. + + + + Represents a disposable resource that only disposes its underlying disposable resource when all dependent disposable objects have been disposed. + + + + + Initializes a new instance of the class with the specified disposable. + + Underlying disposable. + is null. + + + + Returns a dependent disposable that when disposed decreases the refcount on the underlying disposable. + + A dependent disposable contributing to the reference count that manages the underlying disposable's lifetime. + + + + Disposes the underlying disposable only when all dependent disposables have been disposed. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be scheduled on the specified . + + + + + Initializes a new instance of the class that uses an on which to dispose the disposable. + + Scheduler where the disposable resource will be disposed on. + Disposable resource to dispose on the given scheduler. + or is null. + + + + Disposes the wrapped disposable on the provided scheduler. + + + + + Gets the scheduler where the disposable resource will be disposed on. + + + + + Gets the underlying disposable. After disposal, the result is undefined. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be replaced by another disposable resource, causing automatic disposal of the previous underlying disposable resource. + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. + + If the SerialDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. Assigning this property disposes the previous disposable object. + + + + Represents a disposable resource which only allows a single assignment of its underlying disposable resource. + If an underlying disposable resource has already been set, future attempts to set the underlying disposable resource will throw an . + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + Thrown if the SingleAssignmentDisposable has already been assigned to. + + + + (Infrastructure) Services to rethrow exceptions. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Rethrows the specified exception. + + Exception to rethrow. + + + + (Infrastructure) Provides access to the host's lifecycle management services. + + + + + Adds a reference to the host lifecycle manager, causing it to be sending notifications. + + + + + Removes a reference to the host lifecycle manager, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Event that gets raised when the host suspends the application. + + + + + Event that gets raised when the host resumes the application. + + + + + (Infrastructure) Provides notifications about the host's lifecycle events. + + + + + Event that gets raised when the host suspends. + + + + + Event that gets raised when the host resumes. + + + + + (Infrastructure) Event arguments for host suspension events. + + + + + (Infrastructure) Event arguments for host resumption events. + + + + + (Infrastructure) Interface for enlightenment providers. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Gets the current enlightenment provider. If none is loaded yet, accessing this property triggers provider resolution. + + + This member is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Provides access to local system clock services. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Adds a reference to the system clock monitor, causing it to be sending notifications. + + Thrown when the system doesn't support sending clock change notifications. + + + + Removes a reference to the system clock monitor, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Gets the local system clock time. + + + + + Event that gets raised when a system clock change is detected, if there's any interest as indicated by AddRef calls. + + + + + (Infrastructure) Provides access to the local system clock. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Gets the current time. + + + + + (Infrastructure) Provides a mechanism to notify local schedulers about system clock changes. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Event that gets raised when a system clock change is detected. + + + + + (Infrastructure) Event arguments for system clock change notifications. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Creates a new system clock notification object with unknown old and new times. + + + + + Creates a new system clock notification object with the specified old and new times. + + Time before the system clock changed, or DateTimeOffset.MinValue if not known. + Time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + Gets the time before the system clock changed, or DateTimeOffset.MinValue if not known. + + + + + Gets the time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + + (Infrastructure) Provides access to the local system clock. + + + + + Gets the current time. + + + + + (Infrastructure) Monitors for system clock changes based on a periodic timer. + + + + + Creates a new monitor for system clock changes with the specified polling frequency. + + Polling frequency for system clock changes. + + + + Event that gets raised when a system clock change is detected. + + + + + Indicates the type of a notification. + + + + + Represents an OnNext notification. + + + + + Represents an OnError notification. + + + + + Represents an OnCompleted notification. + + + + + Represents a notification to an observer. + + The type of the elements received by the observer. + + + + Default constructor used by derived types. + + + + + Determines whether the current Notification<T> object has the same observer message payload as a specified Notification<T> value. + + An object to compare to the current Notification<T> object. + true if both Notification<T> objects have the same observer message payload; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have the same observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has the same observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have a different observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has a different observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent a different observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the specified System.Object is equal to the current Notification<T>. + + The System.Object to compare with the current Notification<T>. + true if the specified System.Object is equal to the current Notification<T>; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + The type of the result returned from the observer's notification handlers. + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + The type of the result returned from the notification handler delegates. + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns an observable sequence with a single notification, using the immediate scheduler. + + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns an observable sequence with a single notification. + + Scheduler to send out the notification calls on. + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns the value of an OnNext notification or throws an exception. + + + + + Returns a value that indicates whether the notification has a value. + + + + + Returns the exception of an OnError notification or returns null. + + + + + Gets the kind of notification that is represented. + + + + + Represents an OnNext notification to an observer. + + + + + Constructs a notification of a new value. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and a specified object are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns the value of an OnNext notification. + + + + + Returns null. + + + + + Returns true. + + + + + Returns NotificationKind.OnNext. + + + + + Represents an OnError notification to an observer. + + + + + Constructs a notification of an exception. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws the exception. + + + + + Returns the exception. + + + + + Returns false. + + + + + Returns NotificationKind.OnError. + + + + + Represents an OnCompleted notification to an observer. + + + + + Constructs a notification of the end of a sequence. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws an InvalidOperationException. + + + + + Returns null. + + + + + Returns false. + + + + + Returns NotificationKind.OnCompleted. + + + + + Provides a set of static methods for constructing notifications. + + + + + Creates an object that represents an OnNext notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The value contained in the notification. + The OnNext notification containing the value. + + + + Creates an object that represents an OnError notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The exception contained in the notification. + The OnError notification containing the exception. + is null. + + + + Creates an object that represents an OnCompleted notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The OnCompleted notification. + + + + Represents a type with a single value. This type is often used to denote the successful completion of a void-returning method (C#) or a Sub procedure (Visual Basic). + + + + + Determines whether the specified Unit values is equal to the current Unit. Because Unit has a single value, this always returns true. + + An object to compare to the current Unit value. + Because Unit has a single value, this always returns true. + + + + Determines whether the specified System.Object is equal to the current Unit. + + The System.Object to compare with the current Unit. + true if the specified System.Object is a Unit value; otherwise, false. + + + + Returns the hash code for the current Unit value. + + A hash code for the current Unit value. + + + + Returns a string representation of the current Unit value. + + String representation of the current Unit value. + + + + Determines whether the two specified Unit values are equal. Because Unit has a single value, this always returns true. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns true. + + + + Determines whether the two specified Unit values are not equal. Because Unit has a single value, this always returns false. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns false. + + + + Gets the single unit value. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + 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.. + + + + + Looks up a localized string similar to OnCompleted notification doesn't have a value.. + + + + + Looks up a localized string similar to Disposable has already been assigned.. + + + + + Looks up a localized string similar to Failed to start monitoring system clock changes.. + + + + + Looks up a localized string similar to Heap is empty.. + + + + + Looks up a localized string similar to Reentrancy has been detected.. + + + + + Looks up a localized string similar to Observer has already terminated.. + + + + + Looks up a localized string similar to This scheduler operation has already been awaited.. + + + + diff --git a/packages/Rx-Core.2.1.30214.0/lib/SL5/System.Reactive.Core.dll b/packages/Rx-Core.2.1.30214.0/lib/SL5/System.Reactive.Core.dll new file mode 100644 index 0000000000000000000000000000000000000000..79d533a37aaa58fc46e046dc1e2e534e1385c51a GIT binary patch literal 105032 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 literal 0 HcmV?d00001 diff --git a/packages/Rx-Core.2.1.30214.0/lib/WP8/System.Reactive.Core.XML b/packages/Rx-Core.2.1.30214.0/lib/WP8/System.Reactive.Core.XML new file mode 100644 index 000000000..4646712c6 --- /dev/null +++ b/packages/Rx-Core.2.1.30214.0/lib/WP8/System.Reactive.Core.XML @@ -0,0 +1,2873 @@ + + + + System.Reactive.Core + + + + + The System.Reactive.PlatformServices namespace contains interfaces and classes used by the runtime infrastructure of Reactive Extensions. + Those are not intended to be used directly from user code and are subject to change in future releases of the product. + + + + + Provides a set of static methods for subscribing delegates to observables. + + + + + Subscribes to the observable sequence without specifying any handlers. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + IDisposable object used to unsubscribe from the observable sequence. + is null. + + + + Subscribes an element handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + IDisposable object used to unsubscribe from the observable sequence. + or or or is null. + + + + Subscribes an observer to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer to subscribe to the sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or is null. + + + + Subscribes to the observable sequence without specifying any handlers, using a CancellationToken to support unsubscription. + This method can be used to evaluate the observable sequence for its side-effects only. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + CancellationToken that can be signaled to unsubscribe from the source sequence. + is null. + + + + Subscribes an element handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or is null. + + + + Subscribes an element handler and an exception handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or is null. + + + + Subscribes an element handler and a completion handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or is null. + + + + Subscribes an element handler, an exception handler, and a completion handler to an observable sequence, using a CancellationToken to support unsubscription. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + CancellationToken that can be signaled to unsubscribe from the source sequence. + or or or is null. + + + + Subscribes to the specified source, re-routing synchronous exceptions during invocation of the Subscribe method to the observer's OnError channel. + This method is typically used when writing query operators. + + The type of the elements in the source sequence. + Observable sequence to subscribe to. + Observer that will be passed to the observable sequence, and that will be used for exception propagation. + IDisposable object used to unsubscribe from the observable sequence. + or is null. + + + + Provides a set of static methods for creating observers. + + + + + Creates an observer from a notification callback. + + The type of the elements received by the observer. + Action that handles a notification. + The observer object that invokes the specified handler using a notification corresponding to each message it receives. + is null. + + + + Creates a notification callback from an observer. + + The type of the elements received by the observer. + Observer object. + The action that forwards its input notification to the underlying observer. + is null. + + + + Creates an observer from the specified OnNext action. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + The observer object implemented using the given actions. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or is null. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + The type of the elements received by the observer. + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + The observer object implemented using the given actions. + or or is null. + + + + Hides the identity of an observer. + + The type of the elements received by the source observer. + An observer whose identity to hide. + An observer that hides the identity of the specified observer. + is null. + + + + Checks access to the observer for grammar violations. This includes checking for multiple OnError or OnCompleted calls, as well as reentrancy in any of the observer methods. + If a violation is detected, an InvalidOperationException is thrown from the offending observer method call. + + The type of the elements received by the source observer. + The observer whose callback invocations should be checked for grammar violations. + An observer that checks callbacks invocations against the observer grammar and, if the checks pass, forwards those to the specified observer. + is null. + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently from multiple threads. This overload is useful when coordinating access to an observer. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload, passing true for the second parameter. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently. This overload is useful when coordinating access to an observer. + The parameter configures the type of lock used for synchronization. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + If set to true, reentrant observer callbacks will be queued up and get delivered to the observer in a sequential manner. + An observer that delivers callbacks to the specified observer in a synchronized manner. + is null. + + When the parameter is set to false, behavior is identical to the overload which uses + a Monitor for synchronization. When the parameter is set to true, an + is used to queue up callbacks to the specified observer if a reentrant call is made. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently by multiple threads, using the specified gate object for use by a Monitor-based lock. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common gate object. + Notice reentrant observer callbacks on the same thread are still possible. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + Because a Monitor is used to perform the synchronization, there's no protection against reentrancy from the same thread. + Hence, overlapped observer callbacks are still possible, which is invalid behavior according to the observer grammar. In order to protect against this behavior as + well, use the overload. + + + + + Synchronizes access to the observer such that its callback methods cannot be called concurrently, using the specified asynchronous lock to protect against concurrent and reentrant access. + This overload is useful when coordinating multiple observers that access shared state by synchronizing on a common asynchronous lock. + + The type of the elements received by the source observer. + The observer whose callbacks should be synchronized. + Gate object to synchronize each observer call on. + An observer that delivers callbacks to the specified observer in a synchronized manner. + or is null. + + + + Schedules the invocation of observer methods on the given scheduler. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Scheduler to schedule observer messages on. + Observer whose messages are scheduled on the given scheduler. + or is null. + + + + Schedules the invocation of observer methods on the given synchonization context. + + The type of the elements received by the source observer. + The observer to schedule messages for. + Synchonization context to schedule observer messages on. + Observer whose messages are scheduled on the given synchonization context. + or is null. + + + + Converts an observer to a progress object. + + The type of the progress objects received by the source observer. + The observer to convert. + Progress object whose Report messages correspond to the observer's OnNext messages. + is null. + + + + Converts an observer to a progress object, using the specified scheduler to invoke the progress reporting method. + + The type of the progress objects received by the source observer. + The observer to convert. + Scheduler to report progress on. + Progress object whose Report messages correspond to the observer's OnNext messages. + or is null. + + + + Converts a progress object to an observer. + + The type of the progress objects received by the progress reporter. + The progress object to convert. + Observer whose OnNext messages correspond to the progress object's Report messages. + is null. + + + + Class to create an IObservable<T> instance from a delegate-based implementation of the Subscribe method. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObservable<T> interface. + + + If you don't need a named type to create an observable sequence (i.e. you rather need + an instance rather than a reusable type), use the Observable.Create method to create + an observable sequence with specified subscription behavior. + + The type of the elements in the sequence. + + + + Subscribes the given observer to the observable sequence. + + Observer that will receive notifications from the observable sequence. + Disposable object representing an observer's subscription to the observable sequence. + is null. + + + + Implement this method with the core subscription logic for the observable sequence. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Creates an observable sequence object from the specified subscription function. + + Subscribe method implementation. + is null. + + + + Calls the subscription function that was supplied to the constructor. + + Observer to send notifications to. + Disposable object representing an observer's subscription to the observable sequence. + + + + Class to create an IObserver<T> instance from delegate-based implementations of the On* methods. + + The type of the elements in the sequence. + + + + Abstract base class for implementations of the IObserver<T> interface. + + This base class enforces the grammar of observers where OnError and OnCompleted are terminal messages. + The type of the elements in the sequence. + + + + Creates a new observer in a non-stopped state. + + + + + Notifies the observer of a new element in the sequence. + + Next element in the sequence. + + + + Implement this method to react to the receival of a new element in the sequence. + + Next element in the sequence. + This method only gets called when the observer hasn't stopped yet. + + + + Notifies the observer that an exception has occurred. + + The error that has occurred. + is null. + + + + Implement this method to react to the occurrence of an exception. + + The error that has occurred. + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Notifies the observer of the end of the sequence. + + + + + Implement this method to react to the end of the sequence. + + This method only gets called when the observer hasn't stopped yet, and causes the observer to stop. + + + + Disposes the observer, causing it to transition to the stopped state. + + + + + Core implementation of IDisposable. + + true if the Dispose call was triggered by the IDisposable.Dispose method; false if it was triggered by the finalizer. + + + + Creates an observer from the specified OnNext, OnError, and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + Observer's OnCompleted action implementation. + or or is null. + + + + Creates an observer from the specified OnNext action. + + Observer's OnNext action implementation. + is null. + + + + Creates an observer from the specified OnNext and OnError actions. + + Observer's OnNext action implementation. + Observer's OnError action implementation. + or is null. + + + + Creates an observer from the specified OnNext and OnCompleted actions. + + Observer's OnNext action implementation. + Observer's OnCompleted action implementation. + or is null. + + + + Calls the onNext action. + + Next element in the sequence. + + + + Calls the onError action. + + The error that has occurred. + + + + Calls the onCompleted action. + + + + + This class fuses logic from ObserverBase, AnonymousObserver, and SafeObserver into one class. When an observer + needs to be safeguarded, an instance of this type can be created by SafeObserver.Create when it detects its + input is an AnonymousObserver, which is commonly used by end users when using the Subscribe extension methods + that accept delegates for the On* handlers. By doing the fusion, we make the call stack depth shorter which + helps debugging and some performance. + + + + + Asynchronous lock. + + + + + Queues the action for execution. If the caller acquires the lock and becomes the owner, + the queue is processed. If the lock is already owned, the action is queued and will get + processed by the owner. + + Action to queue for execution. + is null. + + + + Clears the work items in the queue and drops further work being queued. + + + + + (Infrastructure) Concurrency abstraction layer. + + + + + Gets the current CAL. If no CAL has been set yet, it will be initialized to the default. + + + + + (Infrastructure) Concurrency abstraction layer interface. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Queues a method for execution at the specified relative time. + + Method to execute. + State to pass to the method. + Time to execute the method on. + Disposable object that can be used to stop the timer. + + + + Queues a method for periodic execution based on the specified period. + + Method to execute; should be safe for reentrancy. + Period for running the method periodically. + Disposable object that can be used to stop the timer. + + + + Queues a method for execution. + + Method to execute. + State to pass to the method. + Disposable object that can be used to cancel the queued method. + + + + Blocking sleep operation. + + Time to sleep. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Starts a new long-running thread. + + Method to execute. + State to pass to the method. + + + + Gets whether long-running scheduling is supported. + + + + + Provides a set of static properties to access commonly used schedulers. + + + + + Returns a scheduler that represents the original scheduler, without any of its interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable all optimizations for. + Proxy to the original scheduler but without any optimizations enabled. + is null. + + + + Returns a scheduler that represents the original scheduler, without the specified set of interface-based optimizations (e.g. long running scheduling). + + Scheduler to disable the specified optimizations for. + Types of the optimization interfaces that have to be disabled. + Proxy to the original scheduler but without the specified optimizations enabled. + or is null. + + + + Returns a scheduler that wraps the original scheduler, adding exception handling for scheduled actions. + + Type of the exception to check for. + Scheduler to apply an exception filter for. + Handler that's run if an exception is caught. The exception will be rethrown if the handler returns false. + Wrapper around the original scheduler, enforcing exception handling. + or is null. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + The scheduler to run periodic work on. + 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). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + The type of the state passed to the scheduled action. + Scheduler to execute the action on. + State passed to the action to be executed. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Schedules a periodic piece of work by dynamically discovering the scheduler's capabilities. + If the scheduler supports periodic scheduling, the request will be forwarded to the periodic scheduling implementation. + If the scheduler provides stopwatch functionality, the periodic task will be emulated using recursive scheduling with a stopwatch to correct for time slippage. + Otherwise, the periodic task will be emulated using recursive scheduling. + + Scheduler to execute the action on. + Period for running the work periodically. + Action to be executed. + The disposable object used to cancel the scheduled recurring action (best effort). + or is null. + is less than TimeSpan.Zero. + + + + Starts a new stopwatch object by dynamically discovering the scheduler's capabilities. + If the scheduler provides stopwatch functionality, the request will be forwarded to the stopwatch provider implementation. + Otherwise, the stopwatch will be emulated using the scheduler's notion of absolute time. + + Scheduler to obtain a stopwatch for. + New stopwatch object; started at the time of the request. + is null. + The resulting stopwatch object can have non-monotonic behavior. + + + + Returns the ISchedulerLongRunning implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the ISchedulerLongRunning implementation for. + The scheduler's ISchedulerLongRunning implementation if available; null otherwise. + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using in case a stopwatch is required, but use of emulation stopwatch based + on the scheduler's clock is acceptable. Use of this method is recommended for best-effort use of the stopwatch provider + scheduler service, where the caller falls back to not using stopwatches if this facility wasn't found. + + + + + + Returns the IStopwatchProvider implementation of the specified scheduler, or null if no such implementation is available. + + Scheduler to get the IStopwatchProvider implementation for. + The scheduler's IStopwatchProvider implementation if available; null otherwise. + + + This helper method is made available for query operator authors in order to discover scheduler services by using the required + IServiceProvider pattern, which allows for interception or redefinition of scheduler services. + + + Consider using the Scheduler.SchedulePeriodic extension methods for IScheduler in case periodic scheduling is required and + emulation of periodic behavior using other scheduler services is desirable. Use of this method is recommended for best-effort + use of the periodic scheduling service, where the caller falls back to not using periodic scheduling if this facility wasn't + found. + + + + + + Yields execution of the current work item on the scheduler to another work item on the scheduler. + The caller should await the result of calling Yield to schedule the remainder of the current work item (known as the continuation). + + Scheduler to yield work on. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Yields execution of the current work item on the scheduler to another work item on the scheduler. + The caller should await the result of calling Yield to schedule the remainder of the current work item (known as the continuation). + + Scheduler to yield work on. + Cancellation token to cancel the continuation to run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler for the specified duration. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) after the specified duration. + + Scheduler to yield work on. + Time when the continuation should run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler for the specified duration. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) after the specified duration. + + Scheduler to yield work on. + Time when the continuation should run. + Cancellation token to cancel the continuation to run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler until the specified due time. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) at the specified due time. + + Scheduler to yield work on. + Time when the continuation should run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Suspends execution of the current work item on the scheduler until the specified due time. + The caller should await the result of calling Sleep to schedule the remainder of the current work item (known as the continuation) at the specified due time. + + Scheduler to yield work on. + Time when the continuation should run. + Cancellation token to cancel the continuation to run. + Scheduler operation object to await in order to schedule the continuation. + is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Relative time after which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + The type of the state passed to the scheduled action. + Scheduler to schedule work on. + State to pass to the asynchronous method. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Schedules work using an asynchronous method, allowing for cooperative scheduling in an imperative coding style. + + Scheduler to schedule work on. + Absolute time at which to execute the action. + Asynchronous method to run the work, using Yield and Sleep operations for cooperative scheduling and injection of cancellation points. + Disposable object that allows to cancel outstanding work on cooperative cancellation points or through the cancellation token passed to the asynchronous method. + or is null. + + + + Normalizes the specified TimeSpan value to a positive value. + + The TimeSpan value to normalize. + The specified TimeSpan value if it is zero or positive; otherwise, TimeSpan.Zero. + + + + Schedules an action to be executed recursively. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in recursive invocation state. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified relative time. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively after a specified relative due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Relative time after which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + Scheduler to execute the recursive action on. + Action to execute recursively. The parameter passed to the action is used to trigger recursive scheduling of the action at the specified absolute time. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed recursively at a specified absolute due time. + + The type of the state passed to the scheduled action. + Scheduler to execute the recursive action on. + State passed to the action to be executed. + Action to execute recursively. The last parameter passed to the action is used to trigger recursive scheduling of the action, passing in the recursive due time and invocation state. + Absolute time at which to execute the action for the first time. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed after the specified relative due time. + + Scheduler to execute the action on. + Action to execute. + Relative time after which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at the specified absolute due time. + + Scheduler to execute the action on. + Action to execute. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed. + + Scheduler to execute the action on. + Action to execute. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Gets the current time according to the local machine's system clock. + + + + + Gets a scheduler that schedules work immediately on the current thread. + + + + + Gets a scheduler that schedules work as soon as possible on the current thread. + + + + + Gets a scheduler that schedules work on the platform's default scheduler. + + + + + Gets a scheduler that schedules work on the thread pool. + + + + + Gets a scheduler that schedules work on a new thread using default thread creation options. + + + + + Gets a scheduler that schedules work on Task Parallel Library (TPL) task pool using the default TaskScheduler. + + + + + Abstract base class for machine-local schedulers, using the local system clock for time-based operations. + + + + + Maximum error ratio for timer drift. We've seen machines with 10s drift on a + daily basis, which is in the order 10E-4, so we allow for extra margin here. + This value is used to calculate early arrival for the long term queue timer + that will reevaluate work for the short term queue. + + Example: -------------------------------...---------------------*-----$ + ^ ^ + | | + early due + 0.999 1.0 + + We also make the gap between early and due at least LONGTOSHORT so we have + enough time to transition work to short term and as a courtesy to the + destination scheduler to manage its queues etc. + + + + + Gate to protect queues and to synchronize scheduling decisions and system clock + change management. + + + + + Long term work queue. Contains work that's due beyond SHORTTERM, computed at the + time of enqueueing. + + + + + Disposable resource for the long term timer that will reevaluate and dispatch the + first item in the long term queue. A serial disposable is used to make "dispose + current and assign new" logic easier. The disposable itself is never disposed. + + + + + Item at the head of the long term queue for which the current long term timer is + running. Used to detect changes in the queue and decide whether we should replace + or can continue using the current timer (because no earlier long term work was + added to the queue). + + + + + Short term work queue. Contains work that's due soon, computed at the time of + enqueueing or upon reevaluation of the long term queue causing migration of work + items. This queue is kept in order to be able to relocate short term items back + to the long term queue in case a system clock change occurs. + + + + + Set of disposable handles to all of the current short term work Schedule calls, + allowing those to be cancelled upon a system clock change. + + + + + Threshold where an item is considered to be short term work or gets moved from + long term to short term. + + + + + Minimum threshold for the long term timer to fire before the queue is reevaluated + for short term work. This value is chosen to be less than SHORTTERM in order to + ensure the timer fires and has work to transition to the short term queue. + + + + + Threshold used to determine when a short term timer has fired too early compared + to the absolute due time. This provides a last chance protection against early + completion of scheduled work, which can happen in case of time adjustment in the + operating system (cf. GetSystemTimeAdjustment). + + + + + Enqueues absolute time scheduled work in the timer queue or the short term work list. + + Scheduler to run the work on. Typically "this" from the caller's perspective (LocalScheduler.Schedule), but parameter kept because we have a single (static) timer queue across all of Rx local schedulers. + State to pass to the action. + Absolute time to run the work on. The timer queue is responsible to execute the work close to the specified time, also accounting for system clock changes. + Action to run, potentially recursing into the scheduler. + Disposable object to prevent the work from running. + + + + Schedule work that's due in the short term. This leads to relative scheduling calls to the + underlying scheduler for short TimeSpan values. If the system clock changes in the meantime, + the short term work is attempted to be cancelled and reevaluated. + + Work item to schedule in the short term. The caller is responsible to determine the work is indeed short term. + + + + Callback to process the next short term work item. + + Recursive scheduler supplied by the underlying scheduler. + Disposable used to identify the work the timer was triggered for (see code for usage). + Empty disposable. Recursive work cancellation is wired through the original WorkItem. + + + + Schedule work that's due on the long term. This leads to the work being queued up for + eventual transitioning to the short term work list. + + Work item to schedule on the long term. The caller is responsible to determine the work is indeed long term. + + + + Updates the long term timer which is responsible to transition work from the head of the + long term queue to the short term work list. + + Should be called under the scheduler lock. + + + + Evaluates the long term queue, transitioning short term work to the short term list, + and adjusting the new long term processing timer accordingly. + + Ignored. + + + + Callback invoked when a system clock change is observed in order to adjust and reevaluate + the internal scheduling queues. + + Currently not used. + Currently not used. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + Platform-specific scheduler implementations should reimplement IStopwatchProvider to provide a more + efficient IStopwatch implementation (if available). + + + + + Discovers scheduler services by interface type. The base class implementation returns + requested services for each scheduler interface implemented by the derived class. For + more control over service discovery, derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the scheduler's notion of current time. + + + + + Represents a work item in the absolute time scheduler. + + + This type is very similar to ScheduledItem, but we need a different Invoke signature to allow customization + of the target scheduler (e.g. when called in a recursive scheduling context, see ExecuteNextShortTermWorkItem). + + + + + Represents a work item that closes over scheduler invocation state. Subtyping is + used to have a common type for the scheduler queues. + + + + + Represents an object that schedules units of work on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the current thread scheduler. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Gets a value that indicates whether the caller must call a Schedule method. + + + + + Represents an object that schedules units of work to run immediately on the current thread. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Gets the singleton instance of the immediate scheduler. + + + + + Abstract base class for scheduled work items. + + Absolute time representation type. + + + + Creates a new scheduled work item to run at the specified time. + + Absolute time at which the work item has to be executed. + Comparer used to compare work items based on their scheduled time. + is null. + + + + Invokes the work item. + + + + + Implement this method to perform the work item invocation, returning a disposable object for deep cancellation. + + Disposable object used to cancel the work item and/or derived work items. + + + + Compares the work item with another work item based on absolute time values. + + Work item to compare the current work item to. + Relative ordering between this and the specified work item. + The inequality operators are overloaded to provide results consistent with the IComparable implementation. Equality operators implement traditional reference equality semantics. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due before or at the same of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is earlier than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether one specified ScheduledItem<TAbsolute> object is due after or at the same time of a second specified ScheduledItem<TAbsolute> object. + + The first object to compare. + The second object to compare. + true if the DueTime value of left is later than or simultaneous with the DueTime value of right; otherwise, false. + This operator provides results consistent with the IComparable implementation. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are equal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are equal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether two specified ScheduledItem<TAbsolute, TValue> objects are inequal. + + The first object to compare. + The second object to compare. + true if both ScheduledItem<TAbsolute, TValue> are inequal; otherwise, false. + This operator does not provide results consistent with the IComparable implementation. Instead, it implements reference equality. + + + + Determines whether a ScheduledItem<TAbsolute> object is equal to the specified object. + + The object to compare to the current ScheduledItem<TAbsolute> object. + true if the obj parameter is a ScheduledItem<TAbsolute> object and is equal to the current ScheduledItem<TAbsolute> object; otherwise, false. + + + + Returns the hash code for the current ScheduledItem<TAbsolute> object. + + A 32-bit signed integer hash code. + + + + Cancels the work item by disposing the resource returned by InvokeCore as soon as possible. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Gets whether the work item has received a cancellation request. + + + + + Represents a scheduled work item based on the materialization of an IScheduler.Schedule method call. + + Absolute time representation type. + Type of the state passed to the scheduled action. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + Comparer used to compare work items based on their scheduled time. + or or is null. + + + + Creates a materialized work item. + + Recursive scheduler to invoke the scheduled action with. + State to pass to the scheduled action. + Scheduled action. + Time at which to run the scheduled action. + or is null. + + + + Invokes the scheduled action with the supplied recursive scheduler and state. + + Cancellation resource returned by the scheduled action. + + + + Represents an awaitable scheduler operation. Awaiting the object causes the continuation to be posted back to the originating scheduler's work queue. + + + + + Controls whether the continuation is run on the originating synchronization context (false by default). + + true to run the continuation on the captured synchronization context; false otherwise (default). + Scheduler operation object with configured await behavior. + + + + Gets an awaiter for the scheduler operation, used to post back the continuation. + + Awaiter for the scheduler operation. + + + + (Infrastructure) Scheduler operation awaiter type used by the code generated for C# await and Visual Basic Await expressions. + + + + + Completes the scheduler operation, throwing an OperationCanceledException in case cancellation was requested. + + + + + Registers the continuation with the scheduler operation. + + Continuation to be run on the originating scheduler. + + + + Indicates whether the scheduler operation has completed. Returns false unless cancellation was already requested. + + + + + Efficient scheduler queue that maintains scheduled items sorted by absolute time. + + Absolute time representation type. + This type is not thread safe; users should ensure proper synchronization. + + + + Creates a new scheduler queue with a default initial capacity. + + + + + Creats a new scheduler queue with the specified initial capacity. + + Initial capacity of the scheduler queue. + is less than zero. + + + + Enqueues the specified work item to be scheduled. + + Work item to be scheduled. + + + + Removes the specified work item from the scheduler queue. + + Work item to be removed from the scheduler queue. + true if the item was found; false otherwise. + + + + Dequeues the next work item from the scheduler queue. + + Next work item in the scheduler queue (removed). + + + + Peeks the next work item in the scheduler queue. + + Next work item in the scheduler queue (not removed). + + + + Gets the number of scheduled items in the scheduler queue. + + + + + Provides basic synchronization and scheduling services for observable sequences. + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified scheduler. + In order to invoke observer callbacks on the specified scheduler, e.g. to offload callback processing to a dedicated thread, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + Only the side-effects of subscribing to the source sequence and disposing subscriptions to the source sequence are run on the specified synchronization context. + In order to invoke observer callbacks on the specified synchronization context, e.g. to post callbacks to a UI thread represented by the synchronization context, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + + + Wraps the source sequence in order to ensure observer callbacks are properly serialized. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + + + Wraps the source sequence in order to ensure observer callbacks are synchronized using the specified gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Base class for implementation of query operators, providing performance benefits over the use of Observable.Create. + + Type of the resulting sequence's elements. + + + + Interface with variance annotation; allows for better type checking when detecting capabilities in SubscribeSafe. + + Type of the resulting sequence's elements. + + + + Publicly visible Subscribe method. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + IDisposable to cancel the subscription. This causes the underlying sink to be notified of unsubscription, causing it to prevent further messages from being sent to the observer. + + + + Core implementation of the query operator, called upon a new subscription to the producer object. + + Observer to send notifications on. The implementation of a producer must ensure the correct message grammar on the observer. + The subscription disposable object returned from the Run call, passed in such that it can be forwarded to the sink, allowing it to dispose the subscription upon sending a final message (or prematurely for other reasons). + Callback to communicate the sink object to the subscriber, allowing consumers to tunnel a Dispose call into the sink, which can stop the processing. + Disposable representing all the resources and/or subscriptions the operator uses to process events. + The observer passed in to this method is not protected using auto-detach behavior upon an OnError or OnCompleted call. The implementation must ensure proper resource disposal and enforce the message grammar. + + + + Base class for implementation of query operators, providing a lightweight sink that can be disposed to mute the outgoing observer. + + Type of the resulting sequence's elements. + Implementations of sinks are responsible to enforce the message grammar on the associated observer. Upon sending a terminal message, a pairing Dispose call should be made to trigger cancellation of related resources and to mute the outgoing observer. + + + + Represents an object that schedules units of work on a provided . + + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + is null. + + + + Creates an object that schedules units of work on the provided . + + Synchronization context to schedule units of work on. + Configures whether scheduling always posts to the synchronization context, regardless whether the caller is on the same synchronization context. + is null. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Represents an object that schedules units of work on the platform's default scheduler. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a System.Threading.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. + + + + Schedules a periodic piece of work, using a System.Threading.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 less than TimeSpan.Zero. + is null. + + + + Discovers scheduler services by interface type. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Gets the singleton instance of the default scheduler. + + + + + Represents an Action-based disposable. + + + + + Constructs a new disposable with the given action used for disposal. + + Disposal action which will be run upon calling Dispose. + + + + Calls the disposal action if and only if the current instance hasn't been disposed yet. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that can be checked for disposal status. + + + + + Initializes a new instance of the class. + + + + + Sets the status to disposed, which can be observer through the property. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource that has an associated that will be set to the cancellation requested state upon disposal. + + + + + Initializes a new instance of the class that uses an existing . + + used for cancellation. + is null. + + + + Initializes a new instance of the class that uses a new . + + + + + Cancels the underlying . + + + + + Gets the used by this CancellationDisposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a group of disposable resources that are disposed together. + + + + + Initializes a new instance of the class with no disposables contained by it initially. + + + + + Initializes a new instance of the class with the specified number of disposables. + + The number of disposables that the new CompositeDisposable can initially store. + is less than zero. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Initializes a new instance of the class from a group of disposables. + + Disposables that will be disposed together. + is null. + + + + Adds a disposable to the CompositeDisposable or disposes the disposable if the CompositeDisposable is disposed. + + Disposable to add. + is null. + + + + Removes and disposes the first occurrence of a disposable from the CompositeDisposable. + + Disposable to remove. + true if found; false otherwise. + is null. + + + + Disposes all disposables in the group and removes them from the group. + + + + + Removes and disposes all disposables from the CompositeDisposable, but does not dispose the CompositeDisposable. + + + + + Determines whether the CompositeDisposable contains a specific disposable. + + Disposable to search for. + true if the disposable was found; otherwise, false. + is null. + + + + Copies the disposables contained in the CompositeDisposable to an array, starting at a particular array index. + + Array to copy the contained disposables to. + Target index at which to copy the first disposable of the group. + is null. + is less than zero. -or - is larger than or equal to the array length. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Returns an enumerator that iterates through the CompositeDisposable. + + An enumerator to iterate over the disposables. + + + + Gets the number of disposables contained in the CompositeDisposable. + + + + + Always returns false. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be posted to the specified . + + + + + Initializes a new instance of the class that uses the specified on which to dispose the specified disposable resource. + + Context to perform disposal on. + Disposable whose Dispose operation to run on the given synchronization context. + or is null. + + + + Disposes the underlying disposable on the provided . + + + + + Gets the provided . + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable that does nothing on disposal. + + + + + Singleton default disposable. + + + + + Does nothing. + + + + + Provides a set of static methods for creating Disposables. + + + + + Creates a disposable object that invokes the specified action when disposed. + + Action to run during the first call to . The action is guaranteed to be run at most once. + The disposable object that runs the given action upon disposal. + is null. + + + + Gets the disposable that does nothing when disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be swapped for another disposable resource. + + + + + Initializes a new instance of the class with no current underlying disposable. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + If the MutableDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. + + + + Represents a disposable resource that only disposes its underlying disposable resource when all dependent disposable objects have been disposed. + + + + + Initializes a new instance of the class with the specified disposable. + + Underlying disposable. + is null. + + + + Returns a dependent disposable that when disposed decreases the refcount on the underlying disposable. + + A dependent disposable contributing to the reference count that manages the underlying disposable's lifetime. + + + + Disposes the underlying disposable only when all dependent disposables have been disposed. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose disposal invocation will be scheduled on the specified . + + + + + Initializes a new instance of the class that uses an on which to dispose the disposable. + + Scheduler where the disposable resource will be disposed on. + Disposable resource to dispose on the given scheduler. + or is null. + + + + Disposes the wrapped disposable on the provided scheduler. + + + + + Gets the scheduler where the disposable resource will be disposed on. + + + + + Gets the underlying disposable. After disposal, the result is undefined. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a disposable resource whose underlying disposable resource can be replaced by another disposable resource, causing automatic disposal of the previous underlying disposable resource. + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable as well as all future replacements. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. + + If the SerialDisposable has already been disposed, assignment to this property causes immediate disposal of the given disposable object. Assigning this property disposes the previous disposable object. + + + + Represents a disposable resource which only allows a single assignment of its underlying disposable resource. + If an underlying disposable resource has already been set, future attempts to set the underlying disposable resource will throw an . + + + + + Initializes a new instance of the class. + + + + + Disposes the underlying disposable. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Gets or sets the underlying disposable. After disposal, the result of getting this property is undefined. + + Thrown if the SingleAssignmentDisposable has already been assigned to. + + + + (Infrastructure) Services to rethrow exceptions. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Rethrows the specified exception. + + Exception to rethrow. + + + + (Infrastructure) Provides access to the host's lifecycle management services. + + + + + Adds a reference to the host lifecycle manager, causing it to be sending notifications. + + + + + Removes a reference to the host lifecycle manager, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Event that gets raised when the host suspends the application. + + + + + Event that gets raised when the host resumes the application. + + + + + (Infrastructure) Provides notifications about the host's lifecycle events. + + + + + Event that gets raised when the host suspends. + + + + + Event that gets raised when the host resumes. + + + + + (Infrastructure) Event arguments for host suspension events. + + + + + (Infrastructure) Event arguments for host resumption events. + + + + + (Infrastructure) Interface for enlightenment providers. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Gets the current enlightenment provider. If none is loaded yet, accessing this property triggers provider resolution. + + + This member is used by the Rx infrastructure and not meant for public consumption or implementation. + + + + + (Infrastructure) Provides access to local system clock services. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Adds a reference to the system clock monitor, causing it to be sending notifications. + + Thrown when the system doesn't support sending clock change notifications. + + + + Removes a reference to the system clock monitor, causing it to stop sending notifications + if the removed reference was the last one. + + + + + Gets the local system clock time. + + + + + Event that gets raised when a system clock change is detected, if there's any interest as indicated by AddRef calls. + + + + + (Infrastructure) Provides access to the local system clock. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Gets the current time. + + + + + (Infrastructure) Provides a mechanism to notify local schedulers about system clock changes. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Event that gets raised when a system clock change is detected. + + + + + (Infrastructure) Event arguments for system clock change notifications. + + + This type is used by the Rx infrastructure and not meant for public consumption or implementation. + No guarantees are made about forward compatibility of the type's functionality and its usage. + + + + + Creates a new system clock notification object with unknown old and new times. + + + + + Creates a new system clock notification object with the specified old and new times. + + Time before the system clock changed, or DateTimeOffset.MinValue if not known. + Time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + Gets the time before the system clock changed, or DateTimeOffset.MinValue if not known. + + + + + Gets the time after the system clock changed, or DateTimeOffset.MaxValue if not known. + + + + + (Infrastructure) Provides access to the local system clock. + + + + + Gets the current time. + + + + + (Infrastructure) Monitors for system clock changes based on a periodic timer. + + + + + Creates a new monitor for system clock changes with the specified polling frequency. + + Polling frequency for system clock changes. + + + + Event that gets raised when a system clock change is detected. + + + + + Indicates the type of a notification. + + + + + Represents an OnNext notification. + + + + + Represents an OnError notification. + + + + + Represents an OnCompleted notification. + + + + + Represents a notification to an observer. + + The type of the elements received by the observer. + + + + Default constructor used by derived types. + + + + + Determines whether the current Notification<T> object has the same observer message payload as a specified Notification<T> value. + + An object to compare to the current Notification<T> object. + true if both Notification<T> objects have the same observer message payload; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have the same observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has the same observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the two specified Notification<T> objects have a different observer message payload. + + The first Notification<T> to compare, or null. + The second Notification<T> to compare, or null. + true if the first Notification<T> value has a different observer message payload as the second Notification<T> value; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent a different observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Determines whether the specified System.Object is equal to the current Notification<T>. + + The System.Object to compare with the current Notification<T>. + true if the specified System.Object is equal to the current Notification<T>; otherwise, false. + + Equality of Notification<T> objects is based on the equality of the observer message payload they represent, including the notification Kind and the Value or Exception (if any). + This means two Notification<T> objects can be equal even though they don't represent the same observer method call, but have the same Kind and have equal parameters passed to the observer method. + In case one wants to determine whether two Notification<T> objects represent the same observer method call, use Object.ReferenceEquals identity equality instead. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + The type of the result returned from the observer's notification handlers. + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + The type of the result returned from the notification handler delegates. + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns an observable sequence with a single notification, using the immediate scheduler. + + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns an observable sequence with a single notification. + + Scheduler to send out the notification calls on. + The observable sequence that surfaces the behavior of the notification upon subscription. + + + + Returns the value of an OnNext notification or throws an exception. + + + + + Returns a value that indicates whether the notification has a value. + + + + + Returns the exception of an OnError notification or returns null. + + + + + Gets the kind of notification that is represented. + + + + + Represents an OnNext notification to an observer. + + + + + Constructs a notification of a new value. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and a specified object are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Returns the value of an OnNext notification. + + + + + Returns null. + + + + + Returns true. + + + + + Returns NotificationKind.OnNext. + + + + + Represents an OnError notification to an observer. + + + + + Constructs a notification of an exception. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws the exception. + + + + + Returns the exception. + + + + + Returns false. + + + + + Returns NotificationKind.OnError. + + + + + Represents an OnCompleted notification to an observer. + + + + + Constructs a notification of the end of a sequence. + + + + + Returns the hash code for this instance. + + + + + Indicates whether this instance and other are equal. + + + + + Returns a string representation of this instance. + + + + + Invokes the observer's method corresponding to the notification. + + Observer to invoke the notification on. + + + + Invokes the observer's method corresponding to the notification and returns the produced result. + + Observer to invoke the notification on. + Result produced by the observation. + + + + Invokes the delegate corresponding to the notification. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + + + + Invokes the delegate corresponding to the notification and returns the produced result. + + Delegate to invoke for an OnNext notification. + Delegate to invoke for an OnError notification. + Delegate to invoke for an OnCompleted notification. + Result produced by the observation. + + + + Throws an InvalidOperationException. + + + + + Returns null. + + + + + Returns false. + + + + + Returns NotificationKind.OnCompleted. + + + + + Provides a set of static methods for constructing notifications. + + + + + Creates an object that represents an OnNext notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The value contained in the notification. + The OnNext notification containing the value. + + + + Creates an object that represents an OnError notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The exception contained in the notification. + The OnError notification containing the exception. + is null. + + + + Creates an object that represents an OnCompleted notification to an observer. + + The type of the elements received by the observer. Upon dematerialization of the notifications into an observable sequence, this type is used as the element type for the sequence. + The OnCompleted notification. + + + + Represents a type with a single value. This type is often used to denote the successful completion of a void-returning method (C#) or a Sub procedure (Visual Basic). + + + + + Determines whether the specified Unit values is equal to the current Unit. Because Unit has a single value, this always returns true. + + An object to compare to the current Unit value. + Because Unit has a single value, this always returns true. + + + + Determines whether the specified System.Object is equal to the current Unit. + + The System.Object to compare with the current Unit. + true if the specified System.Object is a Unit value; otherwise, false. + + + + Returns the hash code for the current Unit value. + + A hash code for the current Unit value. + + + + Returns a string representation of the current Unit value. + + String representation of the current Unit value. + + + + Determines whether the two specified Unit values are equal. Because Unit has a single value, this always returns true. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns true. + + + + Determines whether the two specified Unit values are not equal. Because Unit has a single value, this always returns false. + + The first Unit value to compare. + The second Unit value to compare. + Because Unit has a single value, this always returns false. + + + + Gets the single unit value. + + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + 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.. + + + + + Looks up a localized string similar to OnCompleted notification doesn't have a value.. + + + + + Looks up a localized string similar to Disposable has already been assigned.. + + + + + Looks up a localized string similar to Failed to start monitoring system clock changes.. + + + + + Looks up a localized string similar to Heap is empty.. + + + + + Looks up a localized string similar to Reentrancy has been detected.. + + + + + Looks up a localized string similar to Observer has already terminated.. + + + + + Looks up a localized string similar to This scheduler operation has already been awaited.. + + + + diff --git a/packages/Rx-Core.2.1.30214.0/lib/WP8/System.Reactive.Core.dll b/packages/Rx-Core.2.1.30214.0/lib/WP8/System.Reactive.Core.dll new file mode 100644 index 0000000000000000000000000000000000000000..e338eafbd51637e13648c39a66b6e1c772f9624a GIT binary patch literal 121416 zcmb@v2b@&Z`96N`y)$=aXLgsJ-DP%J+Q7ncoh`6*u+bGnilBnnD2sr=#T~E>vn)}u zVv9k=M6q{`y(Tt-U5Q_7L}ClZm{<}uCYsIfdERsHlm$yZ|NkiGocBHNdEfWE=RNhF zd-vcYE>xCMDu93g{jX9FBIa+5gg+d#BfGTs!=>upq8Ix-XiR;v&+H{jQ;Air?s2X2 zS0onBU%Ap*b`BUY+R(x%p%2F;fq7+{R=1qI8t{h~di7#mp?Cf- zq13TWt*O?9K#FdxyA9wH#Cg9lXs)K#mgO!8sVj9BUYmEL8<$s1l8@7__)#}g1=ZH; zmAbIVP(^};KWtGd8dPdVLaBBS_e0T=?vJkh<9XB1c>2f#4xH2dj%8oOs}5iDp&HV$ zq_pzo8Mhp=|0Q!CIP&5XuG%(nY2e{E$KN)*ZPJ2Mo*R1UJ|FF~SHDZ&dhV>Ehc0-3 z>dQr+yfEb0rGL6?{OW(LD7o24XAYftYvn@^KY#vNAC6tP*T}Z|*v?P-Odk5PiF^NL z^ySwUuX%4-)jmsmU-#kSUZzu}R3v$W*%)m_)mEjd0iJ5MbwkwlS2#-BCkRqC0Nw7S ze5sJqLb)!va@HQpeEmaZ0^raykHc;ff3$RCUTKk^udheI?;k4k17;0snLk=QzxsK0^@@vK zC;$It*HW)ezC-#k_;(*I#&{kP}Pw1$A-Q%G4t6Vmja(X*dZ9 zC>d!?r|J+zL*dK-#G%xqhO#pbl4dx~0{uHedm&0e%Sfohu4lSIr(y3%stJJuG4+v9 zn#H=9Hi{&&Sp$(e4+RYOF>p?LT%~W;B~edH&4Zp6ZB@{v=~8(rmIL8%J|JS#Y_(Yjpaar zdUq)KWKozdJk%sjJ+d)G!o_*k)!pVmr+cx*wkHUv`H*0ywcC(j%Fs z1(6=bG%YB7HR)?L+%nUnfpzyrkgR||!PFSNA!{FCC~IHDcA8;Gg;?4-e>h8x{T`zH-jy0hA{kn9{0lj;Kj#T>$UOw9Mzf=4C&mi!=D4QR zaMfj^DrLXrc!8deky6D1W+1X6BnCo;i$ELS~f~v$&u@5rmOXRWhEmFfPF5}=Vbd$}(DdRb*!u zyD@5}S-?#o;KZuu#fU1aQ7{bFy096hGx?co$;WG;8Z%A7TKApBo!EGMN>ynOy#yy8 zXHR^(nQ3Y+weG}5>r$#px@#U>C;SmSioE{wcGh*`k$6SGOc!H*>0c2n4>-%f(oB~E zZtSV?mV3P5N`Q-Z7!kM&lRJxJfrd~l=qyL>4tvzkz`rsYFY%e#<(9{c%-t2BiZ_?) zTz4g)Xnm0x*Q_S*j23~Ht$BrXmF}*K!#G;AP`R1U%%wtA8EUyR8b-;GF4<9oeu$~n zR26E(6kT^y9jiuMs-iTZscu*Oey`I?U8BOcsG(T*ps$;15b`6i58GOVM$6Ur$>fsC z6PeVuHdSqZy&jrkrdEMdhCIA2#Nw>u!7~D83PX7$gW)DX&n3!j1txh8yHT!bbe4so z2SZT33xBLnp3lCu8%e+nY8tffkJ6xy_1Wnko#jM`Hq$2|w44Jmd8vdEB;b}-mch+7%o+~?@l_n3{Jslw@1--=Mf{yLWU-#~+ zmh`?|;C!(ZCO@&u1{O9mXEN%r&qAc_GS0Mu&H;H!j)q0rksU~#jS#~I_6nB51R=km z6_C2k49;kn5ZI39G@NrlHzXbm&R9)Qmrk7v z_6R4<^cBEZ?k^EWcaHM3uF8q!MRRRkuDbM5qjY_2 zg$08uXML_hnTQ?CY#}c*b2X!Q<{CzND|0QAX@+K+)vyAn=ygb>u1Da)x$9+TqG^&% zZE<#u8=6nZb;v3=EhFbzct_4!Z!EusDS9aK#^zGD5?tU`)F!r4Q%yc)Rvi#7;Z`%VuI1P210^KU9+by8sxI%t# z6>_pgxeVFal^M#kVa8j@tO>F;CZ~%nf`xBDbqC+BIpWjtnzbMuBkrG(O9V`zlR9!;4`vP_pl;zV3Fe#XuB6!=RO1t(N;A4 zs?_~RpW12mumVA+G=Dl6ZKfXponGcx^rN8cnX6du2a!Yne+V(R0Y5IzPLsB9#*$9) zFwoK|wD`WJb}OtigX##_nZH62*7ww?)07#o+IpaKG{(?ru4kut1d`f`61;;!u3mh_ zP<4<|jd~TzF`W}o4D)-)b{|DqY~4@?ZV+gTu_)7xWgJY{q=N4Tg3_~-x@0ueP>ywM zFqHZYN*9OS-wG38QjZ~3Qsh2P1o&_s>5I6A{JiO|A#UdeeVGYl&`(y1{5{iSw9qqv zrYHD=^pQe(f}r>P9}DXQ9NKcWu-4RZU+9Q_6-(VEes5-&Zwpm{6TtoNru)OQF$$8% z*$5t~Fnd@Y`#w4LVuK;zj|PgR?(z7Oz)myl%>Q1Wzg5U}nwjnkax+~kyswr9qwd(X ztDfY2pU0bI7;Z>sOPS6h?)OFL>^)Qg!upA@{yAZkH5#&dQPu;VEK)%h$!saoS=NKT ztiW#7sS^nUL;_|Q?SHyHy(!}%PX_5AgM@aPKxY{b`!aO)p6i1{PZ)16gq9=H{Q4v) z>k&^DsUVAFcA7wES&#a%y!y!bMBXR?`nU5&u7HDOLVfZ_sW9p17OWVdlGHQkVsP~O zQ9zA@?fX#I--xbOhBSp8+m>>LDpbN}e@msG0xt)Xe1V*LEoW;dIejVTF;5O@I?Ew$ zcR7z!&hID(lX87>b784H49u7xe+n69J9v5Hnr6G3DG%_Aw{8dJ55|C zow-VTGHV>nd<9|}wHVJhzMOuP^OPrtB%S3Dw+A^}v&O+p^HXY#f%~VBVXQ9Dx=Cv- z#_@ITPo00~=}dyoIuo}CowsFegAu$y%0MlplWj2H#8OXta!Ary4sm;s^Gwz@7=`oX zSm?6b=ua3t^_&)9A5a5C4l=m*eg?70mV6co*^=meq(2^yCYR^P1;b>$?8C^zA&=)h z9xwPjUi<+bFOi36Lc5}ma6cDIy(~O}neD=Z>*3#LnH23-oma?26hV2P52n6Y>i;}G zuV(qY_5*xgCm+u&Sw8jT^M=Rg%`Bg{vV1TTb~5iD$fvVD4djDyOx8j>vV7jzGoPfn zW*%nP$_}ii^j_~E#Qa(AP84Y{l9u~NCLA5Ny$e9rFYl4#`v}^J61@8XQfB%?gqHg! zg!)Mb>KIT9z_XFM?E*fkSHRvgmXCl5-~g1XbFPSN%Ucuw85vmle~c*g7X%3&d%2$= zRad<+2)&ELar>HZRVYms*Mw8&*T zeIa)cmO_{_GZ^l zk4ETzN8#KL!KYL+ZSl5@4`znhm}^OE3oUxi4h{scSj7Dg%kkOmSd`gakZ)`aEC%KR6+%2gnv z3@rMv=0?Y_PZhdH63@7$*MPZ;bz}GpO1ie<*E@y9sz0X=W%W z6wgpDA~FwEW+*abrXz?f^pGgxR51bj$AF{W<%mO7sdFJA zQ^B-6WXe<`*~Lh+Wg;OY*fg20%&*ME8KFAZ5$dNe8j~j8cCi<{R(*u&$71dDQiHxBjS?+1Mh`#6jg+G%g3 z)8b?x(oU4%`8-+Ac|kQ9yhcEeLVleVRP@=?J)gzC9X=c6#vQ{BoE9^4eX2Jgcfg*U z7W_N=Ep|5%?ojgmwl6^Xt>j^Y0r$WTAm4BM11$7gp{)b@NB!1T>!8O-+Is-#+5RjH zhoxLZWR4c5Ncb(5=NORD(par~j*B_HUb5-9qI=G9S(uJXwL@BM&vD7U&~dfjj#tgA zvwn-!w)ibpzIdXFz{NT*-)~1zZ>*z4Z>)2&ev5J4_uFP9;jU~Q@mn@eW-#+BGea1m zHaM*J{8lh&hQ8mDRleWO6u+GzemjhLu%AEHj;1~zdwxq2_$}$}v;ZCUU+A~PQOX^` zqW_EEV$RZjdlUV3B#O5a)yBZVqA1^Q_x>qOchU zWCVHRE$04MY6@`F`yj;rcsrG8J>DLSB>a}GBYw-~$xLH@Wo9}f_$|E3^IO5B8Tx)p zR>>y|N3YH^I0mWf=uPlZ^er~_w!#9Prs#lGPy&mF|FHxXTJ_1kcmjL~wUhfyKXI** z@ZJArDm)9t+lgvp;9?zBpB!w-X`h~?n_4mUta3JiIN8(+XU?W!BQLG{?Y;2l{m>rW zHe!*1M?>-4N!c}a)%Fq~c+o|=Ow zGnZ-q0ooA+f|+@Y@KE|liG!J=7zZ*(Gm3XqWR5`sYsa8+!E=9(BhInRGt;D$v&+nU zjUcPc0;a3Hg4MEWz*CI0NJ~p*hrJLqsYM8!&8Uuh0gT4W6fHz^;ptolj7IDGRChu4 z7|QOiS)?h-S&Tr-Gt;7enp(TZ5zQ1Q;{=*39_0gG8lr!R|9rQjBF&mr4cW`|Sh5oC z5(Ib{kI-3`4KOg;k(~{uSEkz#b7x%@u49E8>>}?;a>Es7n$~rXM^IP45gVW7NO3OE z^Vn!L`+R?GXtFM{HZ`3UpyGfd+GQ7~-8}m_E0Ns@<%PFP-uVNh_e?mf8i(b0ALjAi zoolwvjcC1Wbu+8L)~w#6#1nRt=-03OYk5dRui#?i0wc)uOLVk629D-@b@JAKN9BdahwPa z=qo2NLSH$VaUgRFBJMG5Ig>T$pYhD8K+0pfh-qii0O0&A9>=q9M9^t1DKZEgY{k4M zb#N3uOU7PEjRhYo8k%S!4W4p`n{Ap5cr4sD@>xqk&N>8DLuR8rMW-}X(j9=Qos}>* zb>J2xZ#E@E#C-5E^ zbc;H{5yI2_C-iL`gfrvGFYl?n!1+(e1;HoeOayo;YbVDAD`$EL2V2v68B0%N_3@J# zxP2n1Q>UXo?UR^#0M=|j0IACM1G72UB?MAukY)-}wYqq}G0p~}4$7e_JrqW3pK9_L z=S)%^3>2o-7ok<^EFhf0SS0GRjJe=94*n4^#ZEcnM)Vsq<07#r9nLfBslX9rT!KswK<(F~(FG z;3q(*%1At_wJI(*oMot|C}DBFh%{7-idV(}7PU+~tK zuqq?<6Z3Wb0Tn~q4{7YiUb+k$syHlm&(%IY=nmb%v<2k?SHL^n@cpE9HLnk8-8Ldd zMRxaHx~h9AL{tRoOJR%4ki_aZ0h0i_oO*n`6B!-xYr#qIJH)lz&B&{d=bR}j+J&Sa zuwz2CGPs&ax2v#rkS*ItJonSa}9=31Goqxeenl40(nnpugs41 z(_lCZ*V7s48z?iFjAv#d;s8zp#-vC_F^>&r1@SZ2lEk}@IKWJ^ockL%Qe(LWpza@_ zt{gA#w4GrXsd9H5OI4qN^7fEA+PMNvpaobW#{DG_oHT^x@c`a4XBlF>{+M3kWfQ!Q+_Zq}u z=Y13jJAX#Fv$Rs69bO)`dDns@w@^l>)cs(R3QyxTVw`uU{)m$8QZ+tfg^_rE6|0|M zx>#G&?XO4FILvl$Kr9N%NZ=0~@ny|XseH&i5}Z78#5aQ6bZ`xb+M&Q-vR;J zt@>)fOy5d9)3-@@JF`y)t@ji|@AH;H7tDmQ)E&s?-Jm-W-`w_&b_oIx08T3w8|F?|N z1PZIamSkQ#4XQBhw3HS?7rnkdY3KS(<}otSBL;ft4;t(VuZxE>A% zq5_!~P$k*N47nhWB^}zHr0hohS;gU8V3Ra_cd}xy*L(gt%wOTX0B~PmNz$I^281}z{~%l=Ibbc zYxgV*&Aqag+J>^2WMio>A&T$6ks@qnST-!=@QhThUtq_-7#tg-&M&Cj8{m4XnWh;V z4oZCuR5awg31o&92}yMt2B-dsjEEh|ECtdIXO>AM+%v3A7~|VFWYtcpG z?63R`oF`DUiQ^SUo+j>FkcO<|fb-f2EyDRJMiQcV=UuPL{6e_vhSzAs4uj1EUr=-Y z05-{Uw3}G*fzej%K)kz$c(v(mR%r)G(1RGe?-0P9GXj>ovjF-dA)oNweBeC-Q#@yM z-UpOfO2t9U*!_U{zJvJjb9inJyqW$J!t}0O@*_$98KE-*BV`IRjK8Ype1L@q?*QX@ z0VsG5%<{NS%L00{6_PDyhTKCULl?&Z1EpYH@E4M@Rh%v8yE4dWLf`i=?yEy6;}cMF znExwcOnrZ2lqLZG!J&gUuG(p46bv?K`%i&Oea7H(1iRJ0!%TkxydHI%HDIRy4pjOd z2)yK%lKcvxHU`#rT48xkjbjDgRga~<1_AYCap*~UZ$hCAQ#eAUe*(}IZ-D>VqCkF~ zu@H)-z5x+={fkVj%)c3>33RG6Gl050XNC^@Tj28QEEj5Xb}Af?;eg+PT;IAaB+Bsw z(SJxJ7j|<*W~$?RilS>|XS>vYNpv*DPRv7BIoMKoV}-5mhYjIVF`k0{1{)eaMmLaO zuJnv-=A|v9^;vCkxLl=~CC9G>n5ThgprNuHchu8l6LJCwg=6QJ;)2LX*(^2^eqLAK z>~S%@q8@0UN3}Za5Xr+NFJi!{Ih5Sl1y8*JnusaR0|Vb*MsLvlUWmTVT3C9f$7>@I zGP5#KMuAK*A|6N;VoQkS8fh$ShXp_84Wb&VFyEz0k>XYME{JWnjHGyh2NCjOh@!!e zX9v#kCG~nQmymG zb5kx8DYVau15F}Jv&ZZ{es-nKK7`YX*h*gD&<0zUMXnBWmKTFLVyi5@Hj_r?T&FMC zqg87Wv1vSqBG$7}PuOTKZ3I8*2ej`)xJwMk)_!tJp2hnEjcJonnr!724Q?DVb%2sQ ze`x?u|85JBxyP)2-K1It$4&lON$)QgnLPt zWH#96?-K*+V$|sfv|nW;RSyEb;etsff;U_m8JU?TMri_2HFqD%yAwAMcr#5+8XIs* zk62b*LwbkO%+dwTP?|htrz|5@eGg4*HdplYETQ)Qrj-vXS z=TJ(kX*<<3^=sTTPJLOaX)r2@pzXV zk&MqS&n&RIPERLkLM8{&xcdWdw#`5?Ltgrs1YBDk&AQJ7iYEw%ApX7=gX}bO3#@>p z*eu}e)EIEj%w|$5ie=rQ07Rnz-zm2*vEHw%9PCGqS&M4aHCs|)bJ6e24MjeB?SgT_g;9#sd5QV3&lPcn_RYQ( zOU(n0K6)f#_~=oL(hLi#m}-aMtY03DY-v8*g)AHQ5mEj!9FOl} zBxNSd-W|nOE|xkDX!2z?__9Ej?-Brce6dlYiZbfU&Y!d$_R>PC+=^xyGGJnPr@a<2 zf2MOhOQo5omp400&9%z`#pOc;bvQ8AbDOP7EA`nr-(}x(c}{13`RX4m-&cz-kS`V4 zy?9oBNrjfrb{K~83t=y zv%p^V_BC0chrRv8EYQW?ev%J#81+U~G}P!gtDr)!A&HQ^9YcVp1SrwJG$546Mnm|l zgmVIDd-txgoK__CxN!;UhT{(0C*j)0s=_Azs_Z5{P`IZrEj;fFSOYDq%(SrSM=y;> z>x*rDN$Q$V)tqR^K7Z-pPZ4Znb&3NU--hu@%pyCSNA)Js!OV$_iq2n( zBJ(mQ0f4{TDgpg)f)UdzPxNOTQD%2wfp`@TlTOyOL3zjT2WYtkV+-2ODJ+2$_%}m& zZ0h9Pg9>rYM};i+RD|V5ISyCTNI|dkT8W(uqId=Nw}iu+`&Wd^ZD$#*hpP@1X)yLR|H1hfm&$3u|T>F6qdUV;i$8K4>mYXJAl#v^425a{tQ7y5XbXf0$SsE zMd+QgL0Z(Ipn@g!_1cC-c_wTq4HSvhq>fd|BF`ixMUAgy)rC%M z>r>FyI5EOLDc8an2z8s4m^NFx$Wx^#Uln{bBVK`n+lDS09o}3Xlol`YOQXf_udJ|j zX*79g1}7C9U3Ar%vEgg`k^sR60l<-Pyf_e$fyX%?8ah`X)JtA zeKcmr!d~N+1_M&(`qI)M%9D}6@rt5%E`;z{s3OO%0w2v7y#fvDF%zreE35hrd$ z1McP~uZx>xvo66c8i;GQswx6I%VWWY65lTRi7-DEViq}PgT~jgDj6%{oHDit%z}6X z{#BzrrsH2Z()?lmI|oIuw+g9B5TQ@;y#eXu=OP1_<-PtDd_vCr0NJJ@x!25yBk!~|QC$J4B`Jb%J? zB~=lyB8Xc_P^Mw7pPk^j>cA;JSbc;Ht`$Lzhy znuC_NV?osZ&qXrsqWJ;INL&$ygVdj*>lQ28ToI{X5W{dR14%{Hj78EL!MnV;yd)Mn ze<{n!h!+dRijl{`3lY7|qh!Wr@tw7Oenn+3DrZjNW>|kI@Y4E7o$-Xtth2VHZas!;ql7=y>d?)jatI_aDi+gHyJjV~u z4TU0NMeBRSG4*ZsE;Y)HgJAzDRdZ(Vkclub_+5W(RH=#+dSA_F5PiUpYZEI{UtPe{ z-YoqH4T(pBgFj@yp?vfQ?#tLG;6@ig^VG!%*a@1lw#mXjJrewfpd0_@!5cXUUB5n+LTRvh7oD!0EY7`Su|i-OrcmLb3!zO7@s(R z;H6hTn@)plIt?a#Z~VfPPe+3c?%n#LZYyY8UB-+rGgF(8-JdIkOOdbTI;QqBo$Hz9+<>qHH%s6j+z;`GFRoRj zS-xtH&j<(+PL%E4d|OyXbEaNV}w|N!7ABEJR(Tb#S{91vjU;9vazcCncv(Cu+9uD2HM~QhzT>vXt@vCN-J==#u zxXqSdF>T`AD`w{^R)tLm2xzX}3Fl@+8o@T~-CHAYFyMQfzyHNfg_{w{xQ?zkSiA%& zx#A;!2?B-f6!vwbsC4$l0#P5+FGSJo7CoQU4P+%fNK#30bx97cO0DPK|9Vn*&(e9~ z`E1@^BXc7&2b-x|puBSi$oT-0NcUD&%m;4E2W}^DqW2EK&7k#ambwEO8O&RO`n6AtWi}nVCDOacvR|b z$?$zSd?=3BO84G8h31Mvp84)W zM(;7rD|PMjkk#`B&eb4yG-7JfR?kai+bite4-D34RoEgvfMiJ#J{2moMPdS=9|XGb zU0ivzJK`99yep5LzPH!l*+cGr8nTAIMfH10pL6j0chB$C-@oH?32f>3k9Tw-Obn8J z<3cw>e;nP@FrL~EK?Tne?!!pqQXv~A|L&yS(BGC_P<_`}AQs%LZv(K2VnHnHuv?7< zu#Wg33E8^M0&2f;ew&#b&%a+MvE5Hm;-_ig%O5x-Cx0~L@5x`Y-s*q-PdmvYumavK z!Re*9_2q_F^DR@onl#_OCdMOPDgtlrFL9D7&s{il;32!$Cj#-ocEEydqOEvf>|Kw* z5>7Xae@9ujMBD8!yWC>A90N@1QE1Ull;EBHFvdAJ{jHB%WEhz1JO+ZoCpcQi{_3Dr zTE|EnSDrjIxrUq#9dV>2_qVfkH)J#GserzsRoI+Wfv7eHT7@wjYYV!o`ves6`f5P! zKVHkmc#f;fd=MdChtK-TxL)`yiDyb(P2X5p@!SbHvf}wQ5-dxEo;QeT;~)*2_cGlC z2ME-M^BCq){S0?)mdJZ_D+QYHf)V+&-Gx95j8iUrt%wFDO7ONb7B$Px9Xt}=0;=}A zL4b!V63I=0`kcOeg~Z0~6#aJKJ)qQ;)IOo_8PV_9;LOFi=zH3|l&fpAo2zBl-TBW6 zamu4k`Vn43!lGw%X9cbzLO^HE+CQMzK;1?hFD8Jm){&#Pr={-`d0OJ@2lys!hM0oZ zZz!_-@hR&Ado||x9|-<wp{cJS>>UU_Xr%Equ5I~-PE2Ty`;XG&=3FJENiw^*yRt|F(gRI3^>D>Ec3G`?>Ye|*XxcP%~-%d`ES zWH$J2)nt^+XD(HekYOL9at8}pF_SS57 zuoLAC4`*cW)9f}pJdC0;JUl|a7#@hw{JVkw;pC4sCv))#i`{F8t-CJXF7k7{ZijD_ zI(I`f9){qmuXlTK3l0uj)`<_bW5aygYyU zEx=A5#CmcYmAGmP^maJjvQ z8evY$>#knA*=n!6@n8~Uot*8jp60%vQc`1A_$L!u9Q{&@%YV7Yw~k-0fNC17eIvKd zM?*aZHhyzJF72M*j?CVz9fi)4vma^iwWPu|VoU=3M2nHs4c`>y@s9UcCpScijPBr( zE1Tc8{=G*yhkoe$6ebDpIiQu<%83rwnuxUYwI+-mCcir;-;m}wPa6G<4Bw81KG;qD z4k*4-ksa5|%C#-{j4Td3e}2i{Xr-N@Tp>M{;4_`2`n`fE?$mbGMZ7ZliCA6{PY%9` zTcXPxf#F@1qO>RIqeJ%^y3EMWl7)jTsv!@t^oCyk3+md^7aS&ce%FJ4C^-iVth zZ5bMZv$O9h^TJOlvzBtU70Q9VA%{rFfwRMB3gmPuBXWMI%ox-s13Bxqf~EH|=-{@e z0JtwgNA$RUe3uIssBC#H*2QICn;6`qvgN&47dL77{YCv9*BmcAv5qwUAgi}_V})zC z@}8n4=jv@aJL6?K+@OC68hP!&bN6*Q`{?|anLjE21GNXhLh@Z&T!*$(+mWC8J%V;t zkUsMYOZf3LJph_GUT#vUywwWgG{H0ZMqyTykVO*xwXgTN3Li&sc zx4X%ezGTZgHS5X8a$W-#9|{LXX|nP(&`~)d306w+|BR?&G>^n#vHS+ zK%Gtl-?o?F$)nE&goi$DF9OJY9AEMp7j2(|;aQ&W%Y%QI=|eDc|3r?v5JW?*`=WW= zkC1L%hg8V@Gm_572=IY0=P!t{_b)GUK0#_VxwTVjeI%tYMM=7F%P)fc=LRKe?b*5g zeJwN{B7Uir&F&#J8}3^D&(&w=n|QUJZ<_Q=)T|_Y0mBP;oeo}nIQ|*DId^TW&g@<0 z{1w{b521MHaT~t?Mdok7VJ-bBvo@P)g4PAh(dmGsPawki40(KAN00k!AnOds!YhC* zJTQQhE+c7G&8?n?mK==F^5A`1d=t+39Jvh#=d%`e=*FFe**RhBb1GiB7@w{2ka%rZBSU!L*tEO4 z_}d7b)eY}aU5zc$>V~zJ7#YOCn{?b5b?~Ss`|b$&#)VhKQN4$U54b1fCY*Mt~(lgW2TV#!!xuBA@MW90lt zuqZBLaSh_LX{$9OP$6{pFirG-_gOEReom5glZWJfvI1>2}qLF%mkU#H}$NHO(2j7F~Y|L5jl9EV`sudq#5D} zHl8X%A`?Nt)jVT2ilB}*<~zjn$8%t(N+?;3jK&PlMkolMVKAI!w64yW11ZA0!!AK~ zsuY29EhVy?nWmn(FYpkjzo`>$EWy6B3t+jbhd1tdAz$aoYyPs$_dadoop}_i6Eb=n z=lq2;T7_8)eMa;z11rmoA(V%d`cYE-K4zMx!1t%%7&~j~_&jGk>WCLRfW{x%C`Z)z zMF&picjw{}DNS@Ax6c*i4`Q(|;7Y*WMSX5^lBDSh+^EHTx-VqX+Il-9^}tOJRob9x z3~Yz`npI95JnhG8Yk>D|_Tfrg zpej<|E7ZFPb4jSWsWMbGd!3j zy!5}2vk`JQKhkU?e*r|+4nwtp+$&M@hBht6yAS!}7HVk7FFj@trSlEvW$QXbLsd;d zT}OF}MGF+P)u_3&zP60MUs>P=PMyx{U8FNPIOaKpnRN<0FS!M-uGb+-J)ufpRu0<@ zoreBnxjhl`(=T|4M^_Ma=p#5^gnL~D+r_0Yk(o-HO{K;_?qY5+=J3fkd~73e1w zddcR(3PA#3VNu5!#kxBF6{4Hpc51K?# zzA@P7cYXFS44e!9IL<-PUf#T#z@h~wPE-A?Da^Vb8jV0AH5@!rBM`LHXuysn zb|kT*h-DS9M=IDeE+V`siYF)#BlEJiTJO@??Gh|DyVlb1P!rxY;LEFs^r;^#;9 z70V!~g&_R;jTv5q1CIWY-irqR%0>|71vGC%0*9ndSZ1l8LnqC6dTEA~4BAJcU2sUw`e3 zIoak}iT2$FCFE{agJto$7|z7TfUkTIVk{DTpgY{O)>LrVlbpe(d{W#QM>2m5^y63X zxia9>6A+l`i3sJ7tL9mtbyjh|m%VD45KXwPyGYj$S z9F1AX=ZPT%Rr}w|&8EDZ5f3GZHsN_nSHw^P{gPPu)}Oz0l;K2ZVPY71u<0HK8W#uU z{FApi&)m(xRZa9$p|&J+4yQ=kwjT0ww#C{c-?qYj4rR_s zq42deDYxK%G_YT89_68j(M$1VtqZav4P6w*t4AI$lW-QkWUd}qInL38pn$)q3;4?{U z%?Vfl@()bF4mGVPw94zWHEltxpOS;uG3w|_vg}|*-_+;Xm%=yOY*2U~-Ra-D2rT$! zQr_{V9B!r-LT1EnC$W^k6^IZe;PYG(AI1yQcI%ZWFBvX4p#~cJ+#a!??-A=@>e!vb zoIPS!?h(6bkJ#T9V$oCZ_kDv(z4Y8?zr`Mg>kqYj)+wpgEi0N1X-Ti`b?f})4T%|R z7A#-7@Sv7cX1m9?tlW3Oh!OLLEgUwydDM`hErUjms@+}Knw6`Uu4wV4&uUq1LMa^3 z$Zy8j3H(3x+_tlZ483E^xXi3u-Ay(3y_FAuPAda9yn0w{# zz7Eu-)iB_2(yYicIUb)=n1<^=$Kca7;}DONEw%mT*<$stIM1>d;>&qDrW zd=hY)FuM;$n_$nwG?BH__U%c>coGZY!C%i-phF8IwWR z3Vcgq{>nv(mgP%VEL}N&HJp?rtCr7Sz1VGC(U@A*vT*6*r3({_T2{5JT-361;Zity zV#e~8`Kgw~(v=IBuUQ1G{GI?YOHXWRn&B0n)zW(6QuK@jcqL9jFG;MP-+Elj>MVbe zy#}0EH`FLwy~OHMR*^q?*!)FJiOGvud_ZeUV!@iF%NMaC^Am?JUAf3TDV3Oos-YIE zRyDu~t06Cua#tYmO_fT_NB$n{)07zRu1qaOUrnqL3unbQO@PVJMY9?hP19G7cUP=h z-a@-l42+`9wa9HrtsJmAv1I;<&?0f-{N-y}nvDJvmZny@srd_*w;%^9EN?|kPDw0i zX<3<=pGqw~Ze`1&CS%Z~`Ae6BBU&j1+pJEka91w%nkpq$O)OmQE<8T5aLIf$F8($` z>47ctSFyocR;*fmN|TY8z90oNqYn9ER=2cDds0TvLm(5Q%*utQ2#u()2o+g~x-=Ps zXDkptV1K|`9kz*Ir`2EZIV9IC}b zj-MaD#IwN%1$A}1le zDMFrGB)ne2CnbCyVY&Js@=7GGW<_5C<&DwBI5D4COb(|Mv($wWZb8^f{jT_{B3u1O zFir_`50mhOQt~;ubZ1eyIu~JF6_t@&|FW-&YSarca(k{~Or%^b?)plkFWyJN-+NMX ztB60nx}~~Yol^5kq(UsCVXpRb0VpB zB%V&#>iXIZwYGY*minaY=GWQkhPq1-{zk$-Ncb-a%Lfo&kFZWn8n78ze@UoD(P!*YW8g*IMo~&5Ft!>g z;ZcHb0sd*x%2vmZo-*22XOAY$W`u*)-J_|`YY1)iZ(xS21NRBXN2`nXIdz}m>Sm<3^dPRfEtc39ZLtpP6`9n~*8c3fwd%)J0hs8#bUUp@dowXtU(;{UQV9ZUt0| zQgxE|gydQHyL8Ok4k)ey(2pa`hmse{M??~O(gK`OK@JDqT@-7p~!_}W9?^?+_TzxFk??>Je ztOP$5>pm+I=Bh7*@-09~K20%biH{}k7)YaazxAN7K&2KnTcC;!1DZJkEm1Ml8Z{DV zDcF~Qwf7@v=~qjP#=SqH~}MkGoU)*auUi7#@k~9gz_|@ zT&0qDv{IBJB_klIK0@TA{4)pz8%1B+z~87K5HO z9@A|>gik758ASaa z0TcxEjCj_opd|F1X!a+`drG||<^C<@o>p&4i^c6h*j+r0^*;Tq$%F9eNI(;8a(PRZv}4nRRb-wEXl0==y8 zss^}xA?04iYoPR2BSdd~MK&B|sw6~RUR7PtyUJ7#KymcbN`VFenxuBAgvnktK`1{` z{RNsT&?m|f=#UV5)n}?+%B6(MXR6U;KRPEw&Aw30=GD-56Cj0mpGFIGtq1LG(n`Mp zbSU!n73eJ~_fIumpuc($PDepm93G^uGdk216XsQQ;S({={Z~yjIVO()6hz;jY6c;F z5_X}}0L>Fs3eH-akD@#2~=!cDbOIy+(A`hY!T=pfw~yi2=tmjG2=RcqBsx> zstV%Iqi|2)?y6G-c_(I^*4^Sr>Q%*(sT zhzs=f-qh^pMs;4^FN_+ik6IIb%P)=V!_(WmNIvB18SYoEqvnzSrd(lq##Z1>Bs9I}q+&aXL7ZReS)-$16T6 z(xv*SXUb`l*DF2&Mr-?B7i#!km*z+xHK6Nqgw(%}YVLX_`0tK6z3UbnF<#sCdW3g% zy$$qFb-f2+|M*|9)0i5^?pV!~@aXvbD5S()hSEkS#!rg|)w=l4qrUYv#qUAxRq>~@ zl)AmHivI@~oo1;%>ecv}uwGdOed*nJU2$BUQ$gRe%2>N~kTtV?SDY>QiG-gc)Ofa9 zsWq$JsA6uJgaaiUgV0bjs%97WQ7ftzAUwH>-hLMF&FUhgYt@t09mTckh3ZI&rCzNr zMfgE=YuHjBSAT}^i|PTud{a%%RyT4h>o&Cnf3+AP?pky^2I0hR#{u(2_0*DDb#S*; zNFUmbemGCU1>I65Hn?41GPC`$Znu^k*8Zx5Ur1O|LrgtFcx=t}ks)eH&3D}lwW8+w zl0NF98lz@r`=%P!l(sU|jWyK&!J2a1srnu8F?GYJUBhGQBZPevEos1iZi}GDjh;PX zIBa-ijbHYZ?(}EPM~?$rx|19E7-*xDK*@I09DGWa^5ve=o&KQP{q^pP;fL>bKer}^ zKbmzl!m=LJCtY?c(i_U2fQDE0sOnA~=0}IChkDG1Zh!1C$;0$f|L!rpyY4R>Pkz=t z22E(aSkKMf4OQI}`w%syCwtk9o~vLD`T+g>IJ8CnSTPHfGu!7Oq$jk&x1Z|zJUA@u zc|Eut-}6(W9s<5r-z5Dl3q#Ve$u@!>N{fZB*NqO=BTUvnR>?5fL;wfVrrjW!x3uBTwFe; zhoLHZKMPq62xqn*+MAlU^ggG@%=Q%0{wTM$cdsHtohFnUdynbStnTkUC2ZTj1I=OW zPenKNIIR6O2|q??sAQrQJVzxa!JexU`}K^eM-tN!{y8zbr!DPetG_stdttZlu>bDp z`!>>SM_Wxy)+cN=t@a$?CnhhGbTfMT#AK)s@m&xm>d!=545(+>iOGe6KVHI*5FT24 zBHHMnegpd2>KgnZFP36>cP(^AI!80D_A%2|-}b!_x%uHdq12ed^t0gLk?CU3_PtLx!qkGQ*#E@_O~%k-h{BD_SXoHZ9Wy}BVYGr?WWbP zLwa#@PXEo#=L2(VGc9wEgahi2L;Afge*nIt_9KLa9J)A#94;SR56qr8tOvfMb|b<< z4p;A0$iW@*2r#>IVBcg*-P_F8VGq*n``clsBfWdBwz;OM7|wn-G1+@CzG>c%?YP(Q z)8Hp#hW7(z#_+um9y^>qzh!t6()adtk*nM2FV1RU2GsY0bnRU_H&{y!<3>D=+}zxe z^Qe1<6zVxKNsQLV_qttnA4J^nqkD%3t4EXQKO1$ zeJ*WAFZGQ;7pbozJ&jtmrJv4I(aViGHK)IZN~5M0Le7Tsv>ul|&Uer1lq#R1K;GbLZ@&sArQk zQ#D~Pt$p`t6OV|q&=~7bH6shnunt$p2((pE&$()a2T`*lRN8~6%RF_KK&Poe#YbB6 z)HMQ8-tpFv>KTD_-H%me*pVx>%V2Hit2rLT`Ylku6ljB5T6~VRKs|~*I4N1bg({5w zvftwts_t3n5^JFvCeW^;vx+xci_|y`8J8Ac1*jzp-DNFSXJ?^p)>5@ypsmKu#ecAt ztN#c@t^Z@KP<^qN=37%A6c-0vCh^-E{AY1RV3pcO@^%?!No}B2XCbeoBpFDl3dviq zjz|{c?C%7D$a8$)B=u*3wkpayMRmm7=n^QMQh zqH{@x-?rd}lE*-)f7^l=mAn`@KMP$~@7eEEEcEQFA<~y0koajmmh?#F9S2>(r}RXn61@HDM@u zZc-CVCI@d*w|UT`C5Hy@RPPFOk?K|2C-`eM2v31z1S?$-yjLCTK~qbY2JcfBdeE_@ ztAh8dS3T(X(vyM@sG&HUV7cQ<*99L`7kbeBC1(d8R^MfzOM;K8V{xiL%KJ;M4nC${ z$U?UUpHStzZjHQ5=>x&7YGf9AIry|XISYLfd``Wah5i$KK{d%!V3w<}Us8u=p(gtk zbx9UF*nVAomxUJCZ>fVu`|{HE4%M24eqq0>ew~Hxu|HJRIK|MKJ#Bxa+6B5uT?{?{ zqPAwCmxF&(VLW-}eVvP;%jarF7HYD;RF`F;wEc~GHw*p3{!XpkSC_lG^kqDHYS_<* z9tc{-ksfq==^t&|SSQe?@L9#5*db$shSUqCp99+L<-K0|FFR~p?Li-wb^yA`gT5}c zLSf@h59-pT9MB^kloaS`4;nAfs{*mdRe^HV{?u%fy0o}wsK|Ic3nfEQlt0f zhDwco<9x~^LuJP5EObJs!l;~}Dd%;$AXH`S5QseQ2z4_WCi>-`2=y>tkjd*JwYbYW zp@gyT0e;@Mp}xk-EHpXT&)AZM0^tG14i9QB=@L#FdmX6dozUgmP=m3z=kspEWqq5B zky3|?RL7u4`wuk!>eZoQ@OO31#&w>a9}nK*3^862o@m=4HOXPdk(#HBJtK_ao`g4s zl!rzb<2#3l##j%!TcBkEQQl4AvBrfO5_uDiH$6(X z?2+(9W9`A@Ldr|51B_n^w5zCF?8Web#zWb>cL2Stq41d4pTbj&H#|ztTvLn>H6%0F z6yqOR=q_ujfyDrRyO6idnr>7Gq~#rA49G(N2+uM`WTF3r4>b-HNY5*CjKe*M^U4v% z5`iv~b~wuTMnkH!d}z^8#<9~W?;;g1pHej6_|k(K%4ZZUFfN>-^Cly2k+H*rj>b&V zVzkfHd27q(0_t&yhAu8Yx@fWSszBRho?c?Sts$xH5`%P{fi5k+%UWi9lg-;^tuSJ< zB+uX+u*&Eu(0j)9<+Xt71llTd@d?JU0_pWxtFc5NTIu+rR^vhqh2JVq6|FWd^PrE) zH(RTXEgDiMbh!kOsDc^&ALS<(tueloyj?~|`MRPLjpEtN)vJ<|jBWx^!lt5=a6gB6 zTNTTtjY$HnN8WvS{x?maP2uhp{IleT3UrYgU-4kkTH{C$np*J`phX%AA6oHpQO4LH z(1!5Q6`$e_&y50Y3a2VwL*8WqZA0(B3x9B`-=UPQTeIC5B+w@HD0sFT=Lw{BS#MmT z^PtPW?DfVK0+GvA)_UW?EOeK3n(>`Ln&$>%!eNx4DK{AV9PUGRS!Wra2t-TVr_MG0 zArRZ)%c66QzH>;qtLUS0BeKy*YREXD%YABNo~_RcZ#1TOc^&08C|3%!Dg16lEONfF z&V&96=tAS?9`s*87aP}kP-$f>a*6Sv2lWHA$#}wp1_8Rvcu}BjYQM_b$Y$ep51Lr% zM6NJ)3ba8+jVp{#G!&j$`Dx$^;~Nd3M*D(t*j(0#wVe~$VjLh4+x@KYb;hv*{XBep zWqIg2<2Vo6Akaz=x=f%o9(031Ydz?<0-Yw%X^?PYyF4> z#zGJJK%i9`0?+&K4Ei*I^oV(vG4d$N+obl2e}-}mNBfWwy~jA+gN7mRKI7&rWJDh@ zUh<&*q7~7Hj1RL=ZS>*n__BX|X!KE|=os?cWpKy$Tce)`G4C;Bmq6>$bH+rU$ol7_ z71N?m8NH5WIX%8?GwKA|ppJ_#jczlBY6vwtDf+ZAB@3MyebzWupsnCJE&9B1dp7UN z=u5^k0&SCh&UWJ)ou|%@-xA$!sQC&%w!@=Yf z8Y@_|KB&cFYi-fKq*_b8qSRK4y>gAURYYp?y@d+l@f^lI!0V81mYEOSu!=j{_O8`p9eY5nGymyNrk*!yE%G4?X1 zO5#=Hg=m;F&abuarD1U!2Zr2!T_PX&VW0XQx%IijopW+dgoAQRy$(S0Y z-ZEweC`^r!?-)B7qfyv&y=&aXm>Lz|HI76%zh=H`Y+oCT_ntAdjnh{kBI zeaiT;#%QnocVjPOgW|ku!v2FXN}(#{@5XV)R15isQSf<^sp|F=(aK_TyDY*2h~ z24Qb9wnKb#;tNSa{$K;eBbgggggnR?k3=bk^mlTY`0>Q8DG74B#vY$IgiA9HGBzll znRshTlFaB^+U0JL#pAY`G|`;$1lDwUiv$tFb#Ky^-RPe`8G5 zkw-cr#7Q~IO!dh8C{~%8FPj)sH8w+TQCMP5*1L`wa#&#)>ki8q($Pm!wu#wU7pBgX z^B5zUSEbI98x@wgA?wD}IdVW_BxR1=t}qeFIxOeN;~KjXoP{!DBWosZ$l50g<%Jsi zQr4{q8`jw46E94iD-Ui`oVO$OA~|C-V~M-7W+oTQYK?u1u|~!yM-$Cr>5XFhM2TD# z#lDCSo4Xi$J*j!}yN*)1MPWQHmCCP0IrrgRmHQZ@o-@%bm5-ZEVXRrXoTE4)h2k|vu>;BFa#Iw` zo?IdKMX{-qE9Lu)y`DrfSCu@aFyqkV;Fv18`EpAAbz?ZQaPmBP`xg{Owx?=YxJ6;l zO(txw#(q7yaB{UAe}xMB-Q=>#HS${uOL`q8xIjLn!_4gYlNZQ>D~a?9V{N{OQ%a<8bW8ETo%*MG${y}l_K46jjGh??U2D5#W7s2KoC*^^ zgp@j2GKgq8UY)#`u|aVldmr9=@?1?}BxTEFa5AP+sF!WguxlpQ%j*=zEB_^OyT(Y* zC32sN$Eh!oPbrK`aEUz1*r0eC=`E2d*I4Nh=3z|beTnp|FwXlD*{Lzg`x5yZ#mO?4 z%7t5FQkKek#*~z$lHS9o9zdEcl>-_hDNE&k#mQ2Z$zv)Ed9O-YCjV~ZY?LY2k`!gN zJx4Cn7|kT-$}JkBnWRa6Ph(^=Zjuy>c3{8Bh82y2$ZjH!BWkw+N24X2>D zPHvI!YV6OzR!DOjNg;hn3nRp$^yiKfgmn5x}UX2~dCTurjJ4Cnp#mOt>;~M*d`*)KskgsZNoBNH)7s>Y& z#=2Z&>T%)?9WB93xKVXiPsaSDv3+v_z~Eo5m;dqb7x;7 z7b;8~nw+0~sobiu;mrK(c6n4|d)&p@t7X9roI>Jv+?ClrS;!cz()S6UEYcWT&t-|m zXuY&Xo~7cUO~76*%NSGRZiif=!V;f!*JgLfW{n+or)GdetD6`C}H zfDEd5oWfdp31cdSwem8}NqVl8S7?l+td%!tjHIlS_b{ePaJ{^hF(qZaygwSYDtorPD>2Ap0AlGYbICDdGr&WImGWGK8F8Mfzkxl%% z>~6XFMv`({V#1W0fIY&P(xpcpWQ?r*muL6L-!i7O?v=kEft`qA2atG*&$2Kyp}qUt={>_Th`Y{ZZ^dazw7aiQ;YJeN~@auP|{e(@5@<+Zh`awUE*$ zOTNUM;$?(wlua6=RmnzqRAa-Lx2A5A({CnDm7~qFnlZ9ud^>xy+|1Z*7}@t__shE( zqxs?PF<+1mX-=xKE96OyQORE^3%8R@)n2ZWe#WR=Ue3Ns9${=y976sE<-iW&92Boi zIgvdmm)%0xHt{;bu9oLTu>;9h%PouziuVzAjXbWg{S*F@eT}5g=dJPVS~*r@G@fmf zQ#D58*>!TR#%MgdPX1EsGGW0!alNePFw*l>_Vse5=A_m3jnc0%k~t*98Y7uE$*meA znK#Kt7*pl>CHZ}YiP;NQ*L+F-P-B-aSX*|Ml%1*{^ zOS~}W9p{~LKw}*_=eX~b4{7XjV0Xzk6vkugE}3?_N}a~mU2-8~JH*bMOMzXivHNq* zci%1hH1=;ftAK4+7>})YTRkrI!kjzJ7}k-q0h}bCM%v4PeN8^b@l>zcEuV{Go7}tQ z>k3Oe1}R^c?=m)+_@|t!++UY})nOkaY>)gzhq-dEa_^CecTftiCsFG6%5jXT6z-K1 zquB2q_sUYuNt%5_uFx21_D#8ku|aW9?mls!9DgUt92DPXY=|)>^FDb8W2&a_lMga> zEozM7Q7p>sv$;lc40|#6T}KR~F*$}E&%MhX#S+fSxChveSmtes1sQwY-;)2Ku@Ye4 zmaj6V>{)xQ^b-D84`?jOrrqF9mnsC*`hJ?s9dlwW17p=X-;xXfTo>3Kj_YK-(e zAkWko>3Kjd(irJ^K-MXY^*kU~XpHncAh&9a^n618L}R4q6Y|9<_L%!g`F<2DG7ri* zcdPvUG51;b&t(T=s`Wf0H>fZ!&u8Q&jgg+u$jdcGdOjoR7n{(Q5=qZzG@0fZyF;#e<@#xVvo5G$#8g^0kZCY*JnTn7Nzs z_vOTbyv`{{WR}LxVyswWD;aChSRZ4b)7TEiF4Nd<#;()YBaD4jW6v?>%NO`lHGM<| zM_>_!iBmJv%p>v9Aw7CglE3J}@^X^QhdXFwru**mG147RADTFNYK+zBzlh=lAk~;#k;m`G~^A z+p{O<9hYq-v9Q=SRw z-)Zb1INy|ymBmtcOFpGAkyf}5U$N~kw}%~6n7FWT)6}=*W0kS6x8+j`6HgTWe(KwD zN>wcE9XU;5;x&Z5Bg3|^6Y>i>Ow9fL)D!ZkE$ol-O&yktus_Ph^I|gJmFFl-oQ<$| z<@ao1f0B>ru+<3rlf1M#7VkZ|R$*drZhroI@+n)``|?*h?7MS2^52(RYGUy|lv@=h zeuH=)%44>$kK{W#%qZ%}|4803KNjzlyhmYTc2R!*Dfx*l>=Wr)z?`BD@jj936vjOc zcPZ(xD~pOf(tN-c<}ml^ux}&GVgA_`<}^RjVZTP0)2vz;(0W7m~U zojKV&Y~ysBM-(Q$T~_RIo7dLIq~w@4DNMXnc9lEF9Bhb%<(l7HqEa}w{IJY5Gc)6Js_6D9Lrl+(@IZDBLa-8!rl@n)DM{#d*jX0^gN?=#HgfITc-Vd9o~ z#hw}F9$VNf^E*21yOqbr%rd=eWASF2s}v>^NgB>+SI_RG1iFeQeAe^OP;D&~yZuQxxHhq0sayjN4$Lxk`tf&0zuFy{K`%(Ck&1 zxMjhyF@@#_wy?P-HZ}O$CLToCT=SzlW4aWXi|$fkNef?;MW&%JPOsQZ(qZm}`vh*X z#2dB`O|_sDKN;mW#S?LqXW}Tt;}CZGrDx#YQ1NRUr`=Dfj0{y2B`2PfBs)e(v-4AE z!idoL)QMu?ZGD2uuX0LI>O3mH%0-NB>U^nKqoEYXqcSDlmA2$dd`lGbe{7>CU~OXQ zK++`Mh9(L=d5OZ=o)`~(#f{%PvBjEY^D9mT%bBiVjm;mQ7or$k*Qd+7U0NN>87;vf z6y46*%$zDOE8&-TTbxo+{?Ea0ekvsv7r%OElS9%h3a$4H(FZ6+FkeF2l}y3McAzUx zRljy=L@{kLEot#`>=Nwy$J2j+bgjHlT9Wf<3d$qClVb|;Sbma*F9qW$|C6|+m6huQ zEZMH7@>9Adz8#^yV=t3WqucXkmw$SGm3lms;)G2fRVGRw)doI$s7g0pb35hJ{3#AhB;;+PYOt>kY<;47^sA2wkKtsgn4t;>(PXMKO8qgG@DTa7~Lto+0V}K*my%H3M zc#r8z3M4{5VE-vVsdqgpN3%UDG{&RoayrROW|+xP^^Pp|E2zdgJDi44DdsTGj5#Dh zLDdG-%2`pAe3h1>Q(LlT6Z;xl@uc`W2ac-Nqlcr+A8>I zwNnqBrD$T!?ff)8jI1eDGWL?R`_){dN<+b)@R(2gacln@PodJVQi+wkwYQDukEf_| z`|rj5@5QpW0VP4@-OD9;F_)y>ulQ9xzRj&d>8x6dS}jwXF?g-0c7nL@c@EW!YFFg9 z+JkBvilWw;{~Rj$x8Zcb6t@Ffsr>JwsM$8Q3$RlB?DV}j(=db@Ra$X|VeO8U{;C8H z;Z(v9&olfjpcH>#|9G587$O!b#eSyzt30Yy?d@5uF_dI`51n02DN=b_b#&<&3Brkg z$s$pt|CU5tU7f?wH95mUriF%35+&H}X__m|BT6G5NMPbJ(bA{#Ip{CT*kF;7ef zcP)N*WG-SPQs+#u817=Yb$IBC<_5S+0GGgBiia+LUIw=jZX?`t;GP3_xhOHb zNNXjY^YL7O=VGziSOsa9z<()t){C7+P~2{GBF1I7L$QY6(7s2Qc;oW0L8pZ;F?D^c2sbN^luo3XuDHj1ANcI8JyGjHvW0)k! z-w*%5l!JV$$RSXQ%wgOQ@S;4zw{jfe8#<2j%>o62-m;k`=*`mtL2o{tUr^phO-B+EG^=zSdr^0F=GB%ds%Xg{4RJ`MhDIfq5dtS{#bLZ1h7+y;H| zaEenbFz9BGLVT5TSXLm`KHMBelnR5+9V-kvZ>%uroN=K+Hz4d1be>$#ob^npH|V6X ziBqIJ{#+7VWD;Cqp5nZC5n7e93NX*@2b`VK33w_y0{C;eg};yA%3tLV8Fb6lPS$4^ zLaS2T{6+q~@Ndg;^H=t}40<=RkiT+wBb9w(uR*tBJ%m`l$}Qx(u?qR?b^MIU>=!_x zcV!Cs9hpLu@I<^flQR3Fq(Y9n-=JHx_8WAI)_#L-(b|u+ip&(&;c0vuwoe=cWrKN; zIS(@DLFPPY(A_i#4Z4l%9yx9HySax9dLQc^IS29&8T7{SA%ou6I%LpW#D^efpBQFX zD(LIKQvUvm;P=`8lzGIUTQH6obW6)|=y0y*1oNL@`U$3=Fz5vLBNh`mkJ7xUf z-;ft!ef)^kk>{6mug4aawuM8tFntU2Z_%N2y1bPopNFrq?{ExBdJ|jA2X)8( zlk7jmeuqi7&!m_nIYs;FL^T8cBl&KoyS1NAQwx}q4QR|tf ziRn$+Pba8e=2^w`RoYLdr=p-=wqBPH=9^c}+S>z77i2QN+Zr zJtl8q30s)5)x2!na|K&WI%yqZ{)l>pJJJ(IF(b(e~M+EGU+tf!DEQSL9tRC zRGt~|AC_+R7dS}g0te|_$dn2P-4L|UK{{7BNauwP(z(JxI#)PI=YseY8r|V@-FLQcXnwRB!ncvIOybd~9Ud8-=j@!w4M%cfF_1waG zZe_|4ezEK)vv#taA=YyzOCDl9hgi>@EP04i-^r;DIq1xIC(^wKap`P%7fZXB)7{IQ zdzo`DOWVux_cH%pmbTYH=hF{yto^LvLG~YF_z>#l`8)$~V9KzAZsw{*txYtC9duXV zu!C*^8+OpGg2N8FRdCorw+aqB=*GQa2i+t%?4a+#haGgE;IN|scL)wU=*#j9mOt#E z@5&A1#)|8Uk0AA5r|juh5y*g@ZurEWT3lVsReI;kDvY^VgH#EItL!eZrAI&@dKPq8}U0fcrT` z!zjq;nwo;p+ma091jfKq4w}Ur35O=%nwkOnwj4(Sy;*$9K{MJZ2hC`PF&42-Ip|I0 z8q;6d2$}0ETS|7RQ7*yE4wtwSa8F*cJK>7TcO8xdngI(EJ{l0|Cs!yQriR%++US60$`kdrhvMGUX zxoS$F*|RBuZo+Cxpc|mPkhV{FwVy)09O`9$Zvwrmu!{Yw66jW}RS9%w)+&~>iaA$t zTtCb4Yd>-Nna9sOevaj5IsOEC$HB|DI(qqjMlavb=;beklf?6te=PM1%0(xaLxjsD z!hWxyua}ef{XQ>h=Va2B1ZuZiP*#6R+=8+yP2S4~h%;_!* z8q~sfCD09DyAtTOuX__{%(*v#?)lo4z-vM-nOzC=HpO1{@8!_F%(*v#-oSVW^ldr& z0skQnCeV#w2NURautN!S>((LWKgiM!vV?;P^p3?a`-eGnm^p_N=)H_1pl=#O@VYU_ z0pDl%<`}=AmF)?Zb0UFmt~|kMolKy&-TnM+?OgK{dnlW)E3vp3QL5*R~l>`pP!LNnh7iuqG8w8pjqwrZZ(B z;{JWiLZ;L^X-2MhQhTm<((P&W&Xs8GP2j{gKHATHfkT^^zsX6h-OCg&$6dwztF)iw zta8#@Dt_koGu;pV*PVWr*~$E!+E4O3Ikc1cJ0btrmL+g2yt>9*BLZ?SB3(#>u|PP&5Z6!Oh4$Po8t~L{h*WHhIzBiDwCw(_N?4&Pi zPdFPginEV9>Gsm&PP)Bx*h$~Y9&ys`r6-(cW#mj%kaR1G`nJK_}huS&&lGvmJ03>V#y*H>=W7izu^`qmnvo7wkQ6}V{TDsa)v<#z3;sRR$rUvAg0F((#6&bFLV^Vyoe zR+XANYR1l^63d=fYL1;hbKVwM9%|-M?O!=>mqD}AF5W5A-V^Hq$Kd=M=cPH`!PkWq zE?VC%WN8(E&*x=1Zkhj`d0CF(%hK#IT7u>zVU@9W5IW; zw?e{!?UG#O-Ru_F0wbfMvIOL-HUdfL>?xJ~TtBbyN+Ula4 zVQE!k)C{@kHrSmmYTG+q)Xo=*f20>@A2$Dyo?o-ypxft8VpP9-%*h1mzb6xDSDwLn z9O9c{hxpdlA-?r>h;O_d;=5&s1lp+XSnDK@FBi)c8Kqs9pXD@hw!D-0o>1VAbWAm5PuOh#NRg!@lCZum}~x$ zy$iZwFW{n?cL??Pa<$)MfT9AZ&_yu(SE{UxcLu|Dea?*{oLr(hcXvj%7)ebr7 zcG@8)eS36-^}N?b`__A1G^_6A64Ky;+X|cC;nMH&yc<_GK?b&KCG!R|FYmeYyK>5tZ>fXg|>H(dl%L)djaV? zk|VCSXU>{`+(q|k9&srP5`D>V1Ty!D<1SiD9C6V*e#bS1-UWP!cUyY_{~>F+z3t-G ze!@j#@-D%9e;191CtXjD`Bm;I7p=w}i8M0r67&@X^@2Z^CW*hye_(!^L9O(p>xD5t zoS%|NoF`pxjrsNb4EV7+O{6be3IJgv0>llENb%$O=K;b>038-DIAA=raK(Z|v0YRp zCgQ`i1%S7UMS#0R1K@K^A7=V*m_FVZpOlE-ogjW8iQgfKf4p3jl89fDXaJlf&jEDH z7Qhv9Y3f+9MLq~PAiq6!tk^2=OdE?Y*sjkQD~9CmNr_^&Or4x4E;LEzDwAZcHc6)6 zd@4Ip95JtTr;4NIP3}Z-9DbzhAWn2hz(mKQ#3FH{m{MCLzAX0T6p6dUj>SaTho2p& z6LWC6;kjZS;Em!Xz&+wlgnkD(DiU+Vg$s&c`P~P&K>R!4jiTYKBK#)brQrOW*aX-i z9tPYXo&XGUtZT$C7A|55b@-i<1&OQK-@$Nz;WZ3*Gkl!kQHH{xbUh4b89z+kFnbaE z8{xmQa5ejb@c(`80Q+|{d|bn8jD0yr*)Jr?$(Pp{ujX~I{|5HoAb*(rPRVYj+z-mW zoX6R}+9dt~hJz;Qyqo>^u>W!PA7KAc_P@q{!$F*R3~L$s818XUx@H2&A4npeYm$ia zWD=!vjQwUZQSuqqF}x@F-Olh2?3IQyT3|Hk>p0H2&M#*!Ql!$l11#!kpykXSdC z@=`Z;Ot!ILHPbtoGQj?8*uR_od)WUt`=4b0QT88WzZl1Qjw5Lv_UE&I5&P@dznc9W z>>ptNHSFKb{ypq}oc&L-|0w&9v0sd5`QuqW`}5hqi2Zf!U(Nmw_7AZC8ussD_$0$) z49zr>lh3e@VF$x&817D^wDz$7NruN5n&}*iVI9K`hSxBBlHt*GihGRxVgmW|Cs3?K z?5|`0YW82l{@v`~!~VzF|0Mg5F%%h`>kQ5{`}5gfkdaR^nX;N;2h(>m+{5s3hEFm) z%J3LNkx9}_h8~9b4C@%KX4t`SfZ;U^cQd?);U0zu7(U7H7{k0XNOEl!!MrK#XLt|8 z1InL6^aBh%GswSsHbGB0!9@&@Dt`^-eKkYRnHF7x|Bl2GJ+n4ix}R!oI>dYPT-trP0n38&*miM&dt`KkI!$)-X&+7VPrq;a-s!)ZzG21(GwNsd%}khe{jA|x z=4}7$tBb!{e7HEPWM0YQlJiT}m0Vl$e97+82TPwWJytroY(d$QvevSj%6?S#QrSCY zRppnKUtNB4`Tga;C_i3qRCp@Rskp4-%8Gj{epK;X#VZxEGNbam$}1~xt$e=nlghlR zctkm<^Ki;JA7^U|5ONkyG0(>N<|52(wK(HkEJ|=j zT81;na-2w3;v}*Pr;s%`Ph5am@l4EgXW<0$Z2X?mBFuNS$i-q2z^u6rvDPC-C(bat zz}bx(nR~!}8O|v~{QJDwsq~9tSEfD+_$S!UESQ~26ZGbBd4N}sn+~{r+#JB$$CU!^ zVfX;UX=%@ca!%UYfJ&NzhmC8K@Ee^INd6Zmkc2N!cnOr-Cr~Q)Pxu}DUz|Yl6DJfV z3$Z$b=+9@6{I?nYjiJmW${7qF&Lo~UGhYY4O81KsNUJ@Q{){&ezdh+c0V}hJ=lfZA zrCRW$L%5ARNQHvf8ZS=MOPFR`ro5( zAJ;fV;P*6p0soe_5l~Fs0(b_)SqvK(Uczua!z~QA1CAH}Zb+Q){|Zo|<(cq5XE@O2 z4+Bb^izmSUl7V0D#O-ZPP%cI9N)*2}u-?SIY>A)*L=q@vG8vR|Kq{07~5FG7j(-^gD@F;{?E+IB%EYR`f9`9z`$1n-A!HQv4MCPl{im zze({TdYcr#K`)fzD0-U|$IuJ$1qyl{-k?CAlj3dkIw}5w_X;F_qpTFrG|B-TMkQc^ zF%Qsb;3QwTj0J$H#+iT0MC{;AaoJK#qvf_Y8lqao8VtAZw73ZI{;hc zmjPGETLD+euK->m?*P11-UZl>59Xy8}VpS}~ zCiwv1_42!bH_GorhnwUN;U8l7CAkm&o8`lR+vSe|cgUXr-Xebr_+|NTfIH;@z+2^$ z7^}aD-%hN>uK*|D-I6ph3GHP%#@aJ6j-HD#vmGO9kJu!x6xX8d-66gq9uR+={Ndy^ z?xLKkoHKJ;b1u$VpVOPOIp?aJp`6EZewOoQ&IdV0Zcgs>+@jq2+@@S_?y6jW?uOh@ zZh!7T?sd60=RTTyAoob_vD^=G^E}m_MINtbmFF_g4$u9bA9^119Pm8n`N$*krsfsq z)#WYE+mg2}?}ogu=G~X~Sl%!5KFD)UT|4#4soSRBKXw1qC#SwOwJ3jneklLy{3r6C z$$u~ZZ~4gu=>-J^g#~97EGf9KV0FPQ1$P!aP_VDyrv)z;6ius|)-Y}TwCkt6G3_tY zKADy?y=?kdrhjevBh#OnUN_@{8SOJJo3UrcPi9oiTsU*Z%+Jm2n)%wy_h*HDDW>?N$ID6IXFBI=A{$}w5#RrN%E;dWjOQw}vQF3d^cT0X$ za-igyk{_2ID1E;4<{KQ2uyOE0^q%vW|r*|lYNmVLeKyJb(89WFao_CeX-%M!{{ z%QMT1%a@clm!DtWQ+{3f9p(3wKT`g9`EdD>@;{eW5W-s`~Q0ug^29E340{Zma%Wbw~Av z>Yr6VTm3?HcFoe7uA07@n`&;YIaqVN=8rXH^XJdsFn{y>tLJ}X{-g6>o_}oqJM-V4 z?--yrs|5bUfpCRtW_#NXS|6K7d(?;@TVAdNQ_tn$T{sSZaXueIS zp*@HhZ#3V#nenuKPdx4Cr=iWMjOW{lxA{h=QM@po=3^Sssg#}rmViX8~46OR<(&g%wU0 zRy5ssdhmoX-$d~AA+3#gHeubh8R_*S<;#)s7qITyg69f6S0c@;@C@J?#B(*CYw&Ev zb1j~2c&@{9J)Rrzd=bx$cwk+_Z>~XE&aE#7yyZz&&v91^foqci+TwAM*SyJon@IHcH?-Snut{ z^MF``U;AAnzKcA650L&6#G~BCT-r_2ZnAdAXg5W>soEW@-ErC-uiZ55rfYYCb~Ch_ zsoja%&C)J@FPz(Ow#MBWpQ7;`jpu4SPrLcrou=Ix+MOx-S>7y-&(`=HjnCC?v35(u zjrescffn;6j#sMb<=U;(?mX>QYk4&qU!dJHwR^U97mNKYuO2SRuNN;e-o$hR@AA#y zKIzr&`P#iuyBBMBm3A-H?rQC>(eCGUdY#(s7RAYwUbjxKSL3}J4{1E4@raJMQM=da z{N1448?}3rc5l;sU)A_GHGZGQzoqeSYxg^vzE|T9YWGLleMGyD>iq22_+#3AT)R(c z_XXV^Uet1bqv2*X|PS zF4OKgny*Q_&Dvd|-B#^-wR^sy#<2^vd$D#e)$VHTUZMG~((a&kZ`SVDw0n^j6>P0FW3 ze8R2}7dTYDA8-f{nyL7{cAwVnv)X-4yMNH`N80_nc0bW_j07dmggaT(=cM5IhvU5* zk?>xQ#B;atwcH`l-oWz~o_FvR8}&KM@qB1LmG>&}SH%yeCIe5wlWZ)@Pr)-5{_%Lm z!ap8QI{X=U(&5j*Gs$=_=L|f@jE-q%fc~MmeOif;IlT=2H$?OFH^h56RmQC|s)4^H zUY_w5@P$UBYI}N1N;r7`xc&e@Dv;8%&sziTI@1ED1J+nmh1-Km+;(;#|_@Q zjcMg`939i{Mw&?p4V9^Q<~V*Z^$Q6d)2_fXi06ES&vATy-nH<5XzqghFrHWDeP|X} z|19B_>JsREZNl9(ADX|x^J+~xc7+*u$U-w0E0Q8SC3w!m(~9Rp&;xkZ;rTos{4HGG zF0!9ALPSNb^3WR%o9fA6ujySFroxaH0o={g? zAha>q5eSQxHDP#tYdQlBndbe zf)@M20T7~0u_U5wfzauh0wH_EHs9KSimd42{_c*Zo{kNp^+DddJNiPQKzB#KXzN%X zpb`pQ5c2i*Lisvhq+@-Q3i%@mO+DS~TKl@YgWc;!g{%mKf<69Vhp>sST@#LksKk4^ zn|%F{-uTY~>jP_jeVvhi#u8O5s<@SGTcoFV6X_0>EiNmpHGuqvQSAt8=;}kI2K-Te zWTU$y&`EV_#S4iQzF=r|nWztjiQdv133df9_fbB=F(wqQuQP^T&=cCwh(;zX4;3Dl zbHuwo6!7_Dtlp5XtGA~!*c}j!U0nfx5E{ioYpt4#ku0B|60qe^;bqYrhjbaDQCbz- zf?8$GPeZERrxPnXv_Y-4sK~SZ(9U8v3f#F zH)$H|-TCU^hzKuLc~~^}_+g-p3b0D1EwHXD&>a!y_n;XCI|GY* zdOC?M9PxEW!tFG!#QHMYPj3%5AuG-302B)f3z8A=b;n4$O;QRyBgj2yHepnmomG{a zjiM{hPKoKU96c=9+Zm`0hlA_7DJwR<*1+1jp1u*J#_sMw$i`yTkKay1*Y|bW2^bze zC5hU;NKbtr;_Fy%tEa|>%^d-BvYzhfNUJju9}uN13v{AshsCmApe|c1;*e|Fw$?e z*2ZpsU~_;+2{CGZh*qRcLG5knw$a)meQRjOV)s)z?TE=R+Q;oZQFXbxPMVJzM<84` z{WenFdSCatfM53*j-pAisp4F99Yq0kQy8NUm9Vp)k34H4{C+bM`JwpHrjjLs5MR_2Gr16EN#Ll^5`h4(<5EccDo~3Aq6_Y zpgK;pF-E(Y@W#9`G4`=IMz!idc-2JE7@I)6rNUb#&i8fp1-$*enD?SV(Il}r=<4-_ zbS}MEJoI$-VLFM*w`M;ti?N1OHMycdi@d(@25UKH6(~mbu3n7Oq3Foc$Q9DBD+^-| zwC(8&bp(X>+(18;DADzRm4bbuSQ@~1h*b`hwPp{hl7{X+G&`+&w1_PZR6vYD#F{Y? z5p-Ffk4G2?D(axN+J-LI5elxsRKoKU0+h$nD4ORHGljQjL!dhrxjp8kzAwBzR=0*% zwMts>VQGRwt_?>6^*oBSqFq^aiT)Nyj}q;(HUwJDRkZi&hAUbFy*(i`cir~+Zm`+#Zf*I~bybhqn)fCMM?uv z%i6W!Kt!wyMB1BsHVMvXd9*+Tv9$I2x&^Jit-7u6@Ah>CJFEswiwl2{=0;!V1p(g% zUY<~Cbzlw+h^2u@ba@+H!*`-*3+`qJwx&dHsNaT>I_(%~{pcE2D~qio?cLj|zG&xe z@?GAK78!0=y9kv%z0wtp7~rrN2wslGlUn>@xbuY~JS;1(B}kFDcvpt81F_c6ZJmJt zN`qoW2MI31w!U6!P~j2Uv2b2rqq)b2qxPv+j#$F0olCSDEPdKV%L;Gf^2Up6y^Sr+ zZRisAglf4-@)jdHV%3JNxZw2;Vp}K%e6PQsj=FCPQ}v7rbH}JDl|^A&D*kKMMJ%4 zUD@2+*t}Gv@9lLOh*9vJ2TWfjH`?}T46%!~>N}D6~==vC+c+nW}*P^oryD9CB+|5;EMR&&P zM%5wOqP4)pFsRm)@T|icG7uWEHf1H2sg4*HE4xGgHIuio?p!X5T5sL5_BL;At2c(C zq^Nj!ZA%LAf}TbT+T~I~p<8ivH+1@X!x+0PSF_k#A2%4DR8(tR5)6ego(DQGBw^&V zZHsMdjpel$Hng_3w6;<=LIdOq2)AQQTIUUfxZw;IB&KGUh{rLbqv znIVf;dxy$cNc8l!H=)eEn8)n?mJlteaQN8UzLZxtA&bL?+L)LdyC#az*o~ZEoCU_@ zFwL;k_UgzUpmL|WIJ!<_IO?Sk%M3tyjGA4-9LbBthn}ag;AAlv2zUvl!V!gxeEw1K zcxr&$jo9g82@sB&8b+ltQa;+OmQ8G<<;Ka3E?h8hU^Bhg*RcU>#ZYh^#<)%-PIehe zcx`Z9UnsyvBPtckdZfz0Hg2eKPHWKK5m7A^g@tbRUb;;rfPqY9yLFwC2`3t*)P)JA%+&_#8}k+4>+_4@@JUENV1Pc&$j6oyh&J3+-B z4Wh=v0qDHYgICPd2p1k_4?=t!6t=RvR%<>Q#PiXD2a-EnFe3 z0od!p82TwBez#YoHt}j_4U3<@rMnX)W$gwrgjt%0)s8r9StsJuppqk{!zjZ}PL7Hh ztsM(bN*?45*tB-FZ={_yT$)?qV4hgtK_gaM!_wsq&EEF5#)}(>4sGB>XfH&?)EI8) z>cv=x60~}hMe1tzQPTmpT1jXtRsuWV{) zZEtS4z`Lxqp|<{Xf!^A-b62#qG@Uk#V|_|!!+9$kTWPJS_JY>nueXyl_(#3o5G@ab zF+$vss4WZ_4AEegAtUFulge11G{sWz3vFYxZ9l^_Lel6)C0d7OhaEdcOdlq4czXLW zyQ_M%+F8`p07HUmY1;Hah6T$E!A1sUE{e6waFG>^K2FOId&F>5J|#ygP-R;#(NsfH zaKzS76%!2{0xR%#8;T->#j*=l`DjrhSsR1yXmk+M+Y=73F&gg{wFV+MjKG-Oj(wv# znZuR>1cr@kVccl$!{Hv5l{QlziZY}P+{y-{SKTNjpWokZTd{|DjS8Jx^lC`YkTz)Zg+`_2$ ztPSn$G;L$`xr8^O(WxiQajdO)J4W3ultY;I=Z#_NWr2`oG!__BI_OvV`a#Q14iap#;-bdw>k0YHgtETu%+ z0$sjdtic0qoxv{E%@l{;r1??lif~TP8qv@l#^Qq-f}(MoAg>M~0~yu@icKMHG*C5S z%Ey^ZBN^@m&6*bkBkQrr3*n$q6>_W@si9oilcR0RMzl=RR4FSX9b`k{mJ_onTO3vk ziVs06i6_RIh%FFp!?LB=s8$L(eNv^R)6dIl>Rpzf=(M+{g*wqK|3b|W*J2iGj<^6z zq9vj2qUO4GtPE&_)!5J`EWEy<$y-ZH2HyRN_6U+jgXr{y+4zG-7oTq}GsKoKD`(a! zWko}4V@ti@nXMf!_97Rm8Ili6@)*Kads_1JMr_vcGU25@h(#uwWnh5T22dV~q5?QF zCjtg#niqj+k5lGRZH2TDWjeGls~w>eSjHMvUqwisXUA~Vx7^q5TZdv9&48Y!SS^N7 z47Zq>k4~#B zrLJZ93YvoJ+nZb3&#!G-*`P)$HpJ8}Zfa<+ZK9d?qW0Rhw#KE+7!gR|lG?^5#Hr)O z3R%{A1nXm41)0_#gcTN|)EX|1KDXgw0DLt0G7Jm1iIK4y2?**7-VTJ)%X z?JZ~^Y^sata6xS&@mYDRJ8iyBlP6_ZI(>dVEicPr`8Zu3PN)B8(Os{nw4K^AQ`@c7 z5w^%!w%gti)~nr-)&M{VTl;>Y3@+OG7!nz1p^ccWU|~wGo_%t)a6XZP%l* zqo*%|4LN+e#oJ6wD{xBG#aoM5%nmki*><5A_Bz+%Lh9p*>tkbOzQ&1a{2pq4S#0i?A+z zfl~aG{WMhz_Pv3Y?mAyD^<=-bn9?Dtn|Ju|auQi1ERpIkH_%O0LT450`e-Y;nFjeb z+M-&UOTD+mAwQ-+zp(8ZA%EmvXXIv$_Y*X+s`0g_)2}>zZ0>4Y+prl%%&_pOV-Vhi zVEn;ogyy0+^(Ha82T@xXY`AC#14rR%(@vzAFLt=HHq_JA*xk|DNAK;3NDr1e+HY-$ zC?-{sZ8OB1AEk^?n-$f3>DY!=4p>6^1uem2tr{8OT@FKDjNu(JYu_Hm`@P7&mnKov zIlF7w1{zj2P-_^64&W&|Us-9W-+0l4u<1uT4UkPE)=sS`fwlVO6EYtJy4G~|dxH_Y zG!g9z7P&q^XMt>Thz~@YVXF)`meU2JeRlW92f$j1*LQ3k&q|H<6x@zuahd~t7+GMx z(vw*e&gc6ui^VwVn%a004B{P_7**#K=HfnjCqZB@-LnZ@m(GWf+fX0bJL=#^sl{Sh zis-V84_JcrW?Z1P_Ya>R3()_!8BIe)(I%aCQgleng@`SOZ!`OB zO6jqS*buZPNT!dNum;Q06eC4zSsfDK6dG$#l}aGQXUJFq;~c>n_wWJ=4kWsH+Y(*X zi-l)(wDW$c)7M{zg;cl{S;B)P@zkgQjH5tZ5YpENyI>vd%9=0}dp6LW{BE;={FAHbwJe6t#PXzN zZ7a1RTfekQ+fs{UQ4iD8zMWhyu$`ygS<~KLM@RPlTI+q_~VpfWrBvR! zL~7|IhZHHDhi}60f>XRWs2IlV@U%TP^mj8HyKVi}rV9OJyx zF`|~@7=89W$%*qQT!t!(GDn>$M$)4u zjSyJDkToE#q$+q?9i>tQ8p>!A&YrQSX#Z@QR#fn?)J*T3_ zK45`I%k)})S_EGh4>Vq8pE*z>q&8 z`&H4Vh7wYd0zz-FPnX81s;#mOUzB1M79pQy!l^n<=dPj`OyhDj&#quOrxESLP+3v% z<;TceVN8lwBub9j3j7T+Dqp& z^g#^za6o_XVG+!PoGq1!{F8 z_ARmZL;l%ZfI_ogU1;g1973N_l+*NbthGil=>{L&S7P-tiUZvWyA4VL@5x8!Wvg&w zB&*eqs7;JpqsPw?YYY1_+BW9d$+lU~PCm^f)?r_@j2eB`kin0tjJ6`QRo7*v-^H*f z7fYFJ)9&8-5D2eu z;Fx!DKb?^=guv1&u~IpJSi%tk2PQv!X+xXd75X)sHrm_P_w>#+q0gBQ5nCZapDouWQtY)os1OZW@OKd0Ob*vgN^U zGDo)KHKZRXu(fTWI=ZG}{;Y$lxB!+{EDTU~u|b9e)O@y4*@x2|(pW6i zmOxd?v`c=4vS?WG_;J}mBveuRSh!RI4b z!NS<@x2+DW1h844SK&tnqQ&big4GJGub35CeMnRUeJv-)8Kx#5lql5Qg_B@ra3p*TLT*LZrb^kK>a7cs4Q=Lfz=>N-@PV@*VI880_V>8QRZM_!9(UW3tUfEoxDJGNa~#$s4Z8GhtnLE@y32NTW_Agu4PM21ysGy>Llt59Ke@ z3+*UfAFvgm(OorS0+rJye18=S6KP)XgpsExR~qGm%FD+RP!?HM&Vop}5A>*x;Po+Q z2U3opltiB5?cf?B4XE7uQE~w;X=vfv06#cglvijz5gQ}8y+{=Y7AO^}0nn33B3}DK z8IdM9xT08@F+Y`q9~_%OJ)I0O&Q3*H8=|%iGH`6ha*Oa~J(Z9ub7}`gD1}Z?A}CpE zKV7)3P_>buRn7x9|4&8Gg~HT)RpCV9l59Y>I#DF+P)($0H`E|VoYYV@B8;*f!Zk%6 z6kiL%tPU^}7Y>!+vY}b1G@>_fI+PV#NH&Gk=}L}uikTEEfnm*mmB%({LyZlu`=U5u zG~nVw5znc^1!m1?V))<$m+^Ul;q4S)ZQ!Awv8%^bkxg)0aff0Zc$OnqgnK!x9lR~z zJ|FR#z}XC>2q>1YwQLjW>CaI^L24 zJQx1u@HHdM3%3<+Gh&HM(ykWiw8JH>ypStqP#O*3@Pd!H;gGL(HF+^%JD7S5( zv_f}+?HtkyNhH74;#(SD4pdSrI1X_&vTmo#-vyi>RZbWN|NPwdCw9*Jd&5nOx28Nc z_dtP2{NCB^SEap>Jl~m_o@7iAa8i{sNjYiC@xVze{kQ7#AE;`s1XGQX-pLL}ITN8{ zh?to^uoZrn&AnIS-_q_wa1pc7NY8|`9FB^aHrT5;1~o` zASq2s3yuhlw9)bs$AT0CERz%Gx{A8(6ExExJzllGP*;z%!yqh!TVx>PzzoI{GG zIAVBumR%E~yU>DsXdy`+DjV`8z&Al8d$@5>+fDVLZKP+Ryb1|Jgv(g92_ijn97l`c z(wRu{)AJmF5?+~}r;me zRr*}4&3%U3jRHyHst&-HOg<`Xw;Q=KKtXY)&&9wY!Nk?zcAGPWbPCQh zE^no*Q})K9>5^ZiDyiR6`_Uz?G(pF=6RDq%5zr((3n`@sNa$SDqm$$jGA%ueoJ!@) zO3!iu8`z$nm4tN3O$(9+>>C(Nfhg@w3r0EmDFr6?rv=scMp~grZgsGF!SsPUveAQ; zwl+GvUqyFFLkipxs7+w-8n`2KBt`RKP_k#vE*=*uoi<3v%!rnOYHpm!q&TAHR^u+K zj%I65W=bp>dx(xVK?_7sG$#{B(=;zi9ZF<5oaqCH&}z_XK^PdM_JB6Dg+L?$VBnC| zxUz_rm4N!m8jA~jRf(am2hOk;Ej3zdUO57#rI^xIGmYD`3bGdmjnF_?4TRYGN@6jS{DNbA$3p(r>I&3@FbuZC#bQCMg$Cnm8KKJgwst` za!-OYci^$SWAGd$3In^5$XQNA%BC}|KLJDLz+eJK zC&q&mnVLEcr9m3Bf=Jw;0YG*2bRMjzlR}Id5*=?MFVq$WJF&oll7j_MuajHH{pdsp zH87ppirgAu(PR+AD%4B|P`68PE_RWenOd8E%4!ykwdjl(>JyR7Oi;!kQIbW|1x*#4 zTiwR>6cVB09k`vE5w38wykn4(sZ1m>$`y9n6K&jgd1EYGPexsR{ijtNKOitT-r9u{sAMf>h(6X^*Oo##i#E z1;_HNYGIO!W?(z!Lo~OY)T+Mkq-KI)m7PqQ!cjXh?Tkd#a9C-0E&Y=`lu61IM*2i* zaQoDXLM`YBqIIB;SW7&n=v7FJM=fq*xEpgkO)fOEOXP%yh_r#dK+&MA5HTK)&=W)J>NS?@Fd@D)EY}mJo@Q8}f2J(jr>tn!HS-B{DT>WSYFz+Jn|I zZcK=vQ-W@_Rw6IQdOQ}3yjCpMx66rW>0Q)>>TS9dDiNfN73%` z7B(f3mU*#&DeftWR+bcN8r0{kMI)mZ!Qi0teFA}K#84RPQxwG%Drs`l2Hum-WQ*-h zuu-8VLkjtojuaU=fJ#ZE=>X#tTT18Hf&U~c4B0(Auzb+AUfFNRhT_q5yq^g_-7`$v zY})X9z~2W>vXz9`IN%43Y)}EXcs&=8%nHgbM7Xs{_rSlFdB|$z;f-!1T#^^FBY9x^ zAe)K@JY<3(%M-p-hGb=VvZRnL&2A-`3pu1eS%KE#>3{?>Q4mepXvhi_1Qv#kj)X1)9)oBE6g|Pq1Ec0JkuP7a|M3PmF>}=H5 zl%>l9zp|=Qnq*_678gPI=(>)zkv^S=c&lO?v>$05ErLl#wM(*>l3dkV$qq~DQ9DzT zsrBQCg{f94#M-XvG4a+{lGo4etq5|+YDeWo2DAvM^KqwlF>=&{)<B275>G_tqXCf#+2Tc-7wZ?(B4n{ z|MvcWQ+pq6G5`Oq-QL=_p7H;3YbQfEjb4_C-h=s-Fq*+>T>9^gi`Mu*dMus+*&d8s zG?vkrN@p?FYJz5dsuvoWXuUuuKyxwLs-8%5PW&iJV`n3DrFlNYGdQg|)JRR|BCnLi<>mjbdC;n*PpgIa@>X*OmGEbq-&N}xeYWO7jrq_DXmv%Wc2rCM z=goqH7stkh_!-`6wY2*A*Vn+5+m*;Ywe^vQYm_F<&a}=tUGHl|tkLvV@Lz_08|0YO zQ!IUzod5I6mUhIa2pqs}1$*uTjz!qT@P6%Q*vk`fN_wW+>(Ma{ZA-AB#g+wRy`_4Z z>DZ}1%jS))^h`2ubdg1)i>w|g*bhP!%xRhF0kR!sQcxxZP2yAsCn>uK5+dUU%)5gn zY)Z+4Ed%~2brJgxBfNf$;N2hlqtsN0J3sn_l@mbHj%9308=EE|J7T11F4*Vs8!}`F z8(hu$twu2+d#e*rOoOYFus2mlV%WmUM6z)tY65hIDt>2x{t6bs>NB_(r3{E{BeQ%As7zDr z)s(SZhN!@ohC66~Cl0(oSB#s|pk|ziMNza4GCPCQSh>$+;8i7Ah<_BJ5_y?}nfj_`F zF_!8UWP*P%6UA6E&WxpomNqzRV7DlM31vXwS9yeRl4TWmYg=t8Syc@D+jnaF8}h1k z*X3-QfAgz1RR3biuzWP|W6zY;7oBz6!CL}3*Y7%Tc1Gqq`_A5*R{G$W=gWWg?&`dC zbH6g_?b2^O_|w$guHtFGx#H2Dr^o&MqAv~qw(@vW%}_&~>&;^ewocDD^TDS-xb2#r zul(Y#OIQ5iE35p!pY*kcS5I!3JtuwX15XC#eDGvq!X@|PSa)y$MTAyfpd2!bIg$Zr z*cd#7;w7Hvv`ct`3vGHPQ4fJlg|Y-X;X@=cqLY!vJ&6$z4XZMZM`RHZ7dhM^5~MUSRbAyS_y4-O-4l8Y$h zL;J7?{zm8JHwcPFv?34{c^c5};E={i5ao3XTxgl09FKD7~+$vZzVOoHC7LkSj@4=1!&X5lDsc$}(CbYyvvo1cNej1X0p#xD?x+e9cA%Wl9*C}BQZW}bh>~b zAlU)uX*%{EgD3pe# zRL&K}qGCnn)q!X-PDKfM1+Hqp@S^l+(BO`Ov@zmS|G~Lm0wc)+CysaEkRUCHs6Gmy zqhA~gDkN?2l0;O=ASR;|G)bwR{2mQygFZTVRh&3^4RRmHFI4Vmd(A*=$iA&!Q1mHM@ zc3B@F#Ch`e)CaUZpsrAvP!7yc2!{X)zz&8V*a1ij#S;~km+^*&j38NNtPF#b#z{h@ zRG=wDd+^?u$9wbz{j%{9vB`K?2>%tsf2Ghdj#dmVzy!fJ3`<54#tHj>Fj*YHjU=y- z4B31lL}mP4IjO;Sp#YM*f_Q@)!V7b^xO6x-QF^EzZVFz{Nc@*mCj}3W!GComp?ob%dut_@jbF*NwWcl#@L*gQ9{0-T`g^ia3(6Rg_;e25MYJk>&4nxWyL-T}S zD+o&vO0P#a0h)&;fc6{P8Tux{ZJ0X+u#ve1KoJ9=22CQIgQwxgBkxTf?3^JVj&u-8 z!ZP#&`a=W_4QO9Qw7NknfKNh(l`5g4EChX21ObFHR|_Q+iQmxK1=}?g#82GNP?`do z^IX8_sK8J%;7s0Icm*=}#$>yJ80#0Mh0v*kw;=zsRC^R>5BwqrL|*XX&u_@XO8Pk! zp%k(Nr@QDBK*u0j3T#jAvhn6VQJf6tk+P^D9}J9*(v{Kf16<5~56ufg1#n0rz~f=G zhdE;glq1J!XIKg(s&nCoQXx7B3T_;d#{Bf!FAB;2A`Lo(*U4Rjco^Tl(=>i8{bL-O z73aX8TgQkWfQKJ3P)hBW6T!=skyrd_GI)84KTQZPM}{+C1XoCc<(rIhg}?G9Jt#QfmsHkI0R)JID3$n$U_>$IU>TK=N`Y{63?&jgG=#=c;yKRhLzxt?^rR%jP{21K?!f>odMGhr6mT>| zvGH_)a`-nqDBy{R5(l!Y;Ktocw4Xv9BS zIPgAq!?UxY1aY0^P+;H`ux5m|!FDS&VGtNNpc0`4RNe3)4ECGC9q*5AArl(zchM-w zR}|RsgoGMUyh1}Ma}p9_#~T{Xjxhj-wP4#76P92Q5))+@mJA>9iZHYSv&je-dkdN| zW@>DVcP$F6$euGGJRcVmbeFu7Yqq z5)vds3Q#^!6j42JbpT`z+2|K?;L;()LGUOB)HKp}fh(K35Zts-UBF>OS3YT00n%HC zW6~XPJg{4U$V|@x^o%RHAvBFt+u+It?;!1}Sk9>cF>aW1r~w-XXm)s)r305#_=N({ zHy}|XNy_{Ll8A^1rw$P*L4KJ?)B)cAqTB>j66v`}vr1t+g7_0CZ^)HLS=>14Sp`u# z6}Xys2ue~&z<0&3>#^`6qB6442=SXSMTiOC+RM;j4Xc zi~Y$#WIzGiGYZ!^#gCi!XAk}O)&;}Sf8iFz@B5r_!JuHRz%Sx2rUQ)F2o#(r?_z;w z4y7b;a}prVx#FP^%n?ah8S-(>Kj0hzlyRuxObmc1x;Q~LBqNd=RA*6Bpo1sFUVwg5 z;D=R(=nr_Ht10m5;2Hz!Yp@2`=}-#F03!z7w^1vFPz`EjP+1RWht}bQBvQ*mJOgiljml#U?Y%GMKzqp(~oeT!1)6eHpH#LQ=n#) zfLic`Coq-arXqzlBf0|OjGTH%7Y0De%gDoRl+!o-jr3D^4w@qpgXheA9u6qJf#xZGsCXCQ*Y%W!7n8kEK9M-)IWSE843 zP6P^}6a;5Z3J>D9P!55QqW~xf+J10xXB`9#hn8Y`4hc1W4`16TG{no}uoGc~aL-l| z8dCU!F5=r@xN;(Dn$?Y%b~sLg5J4E`kcdyAD7qMME7lN1jc}?KLO6-j-e3UOt;#|m zY`|w;S?V%qbDc=x{QO>;0n1vR5MtX1lrp$+;{N55bSSwPghVv2;L{5Q4JPT z`Bh(lMJ&h%#Yix?^wZoyBPB^L3w!`ZIZBWp^#tX9HyTt7z1D?*56@=^B50!U6j*ZH zkTjc!)*pK)haVzBLhu9VToBGNHe#c45C#%E^5l)^WaL9VV{<=ny2rlgq1-2jD`R_yLLX(7}mw z^+4n)NJhO;hW0>Ug|8u4|FCS?!f<#)JHQG8F(`TiLs7U*u`nPJWZ2@I|3&Z>hs!dR zaG?htgp%Jqhe|mQm2&2m8hrBFv&JbAYXom)G%7S+yt<*FGu|a!j*7Zu4d4XvCQid3 zc`3{XJW!%HK2I{NY22qDJb@Q7C<~QBokl`MSfS`4gf^29fF3Y98X8LD2gxcMc!VSg z2?>x!!cLYz<~qn0NkR|~qJuJQMG3UOm0{{&3E>z7&KlGMj^I=TEf7vn4DB>t1lUA8 z*(zEfB2pr@?IU+%l<2poVKJJ@f;aITThMLgmVX9Pcz63{T3!UP~YZZwE zIj(yVo%w_QA9!z~(-Ex*!0Hr0J@__(t*j1I0g)g+%n6AOG(`rZ1{^yf!7ry>&a<8y zKZ0Nm3td9Onn<7zUVFLj0t|4E1qR?t02mYCmlbYZOmHNG`x3BC43C8Sy`Yf+hW>+L zp=!`Vg(*yb1ThI%l%0M=g06vwgSRJqtP6Qq(Bt}NwMa5DVCaG0kTCGsYQcS)m=X!z z5^{sCagh@YaH@d3SjeGDD7;!I$k$A00)o_FpMgUHj>b6dR0%VQ1Rro+f+tai{Hy@q z1Mc2#;lXk6VF^kIc%=jm2V#IA{sko@60s2CaW=uwT@!BVap0&PIY|On%y3y3B@zVS zGZW}LDFiJdLEW8q@27y9n`nx6Xvm!Cn8=vfz-Z9}K1c|>GLlG;{Y7^O1S=w8{K*}Z zKdpj70T;Ox-1}}kutvZUL{cadDi$FU_(P-hr+R_yIWFS@A-yQgfNDU;XjCHuBVaAe zg}W{DM=0^UO6XBM!5vI^2z=hu0>fxV82U3Z#UEyz7={^RG(3Tu&!92rMpQZ#mBiCg z2>t~#!a~fjP!o)15@u{-YC;V)F`);UhA~4;&FH2frc@@=2%`lD88d>-Xc(1gj4{mU zp=QP*MrJf)1~t^w)GQ=~N)MwNQ5m7Z!3;Vuy{OPmP$(A6q|@mkjL=Z%3f0(z#xygb znuZ2Jo@r2MFcV`2VVDUmjK*M^nlPaS)RC|-Cd14$lxf5aqBBB`j6&#UrXfZQBRXah zY8pzX2b&tvjHyO+W>9E|Ss262*pzM@W@Zv%8fIc-!oWfqW+sdfW1~k)yKz!1-Sa=Qx0K1sMe_bHLK>j?zv34y?WGi3-nIN zct89EkN2bcO_}C5C50A14VdEX9su7Z4i5o0?0#MxmqC7T?)tgIG09Ev`*9hdBh?SS zY~aWJB9o`vFN+w&GJ{bE|Be3k)$pK4AY4RY%C9?jd{{XG0lsh*XCE1fKthO$4}sB# z8ZhCDQt0oSCe$JI>stPk`ZENGIIu<%2I>Mc|$I;|BHwGA&U;Y0HFrA2PH!9h8+L=T+=;J zj3k1M6z@MHur~l05Sj?SkdCz1qi{WS>Jb{}Wq)|QOe~AKaaFFjTWdDY&COEbf zNT-`;V}&fTg7JRF;nr&*cp07r8Pd~6b{0G<2MW}U#=^0A>Gbi7e5TI8(CAt zfd)A08M2Q=`t<0JNfhyMY}|CdX`*%F3LA`vjQ<#++%aaqn;{o+JHQVH8q z7m~C|L?TrbY+d+uCHP26`~=KRKtxx7NG7sPNJMgpC1#F|7?vW53G*R3pp2AGz|@Dm zN0uXw4|KHEPd=b6C+vNCl~xs=3;`>)+lo z1uO$GOnk6oM1JT(D&8Z$sbm3J(o`?1EG8`g5g}O-U-*(PFpm;qqN!4t1WFW?6`T^v zjEae7QdKc!lp-Q4Kg8St$}u(ue0+kE4pjqFNBMlRO2hM+pyvYLhtL0&@zR>2^WHbKP8N<$`w$&GH;sVvRS_3;la_yB_0E#Qy;3F zRSH`1=}Wn^rb5&4X?oOU*}G|~*>@LPCiwPeZZY;cZ}U35K73P@&&%k?d$ru-Tbc9r zsoe<5$R?=2o-=L9OqZ4W+O9HgT)2&G_WF_*u^~hEfcor&YwuI`2Q4jJvtZn%+0PY^ z-aZu4ZSG;Yko5BH;_6G12Uv^xK0oWvcRsw*VtJF`YUQ^LiI2a8P{wXHdu!uus_MSB~Adkcp(&a8lKRbVApTacaITHiAg2F+!4I*lo z4=SKWo`kt$t|cxdPFW6Iy`+%1$R8AwVk5#0A=MB>{^&bj@rJPez^g1QJ6Lf6n5jOU zst@cr%m4~uGkAR@63HHz8#a*_$4FV0+$NHflYi9&=(YV(-3h~&3~V!4GDO0-E&Z>K zH)^FV306ueo_TtpOa9ch6xr4hUOJ*;1Y0Xp$((yk#SF$`=YyACrsb5jOxp4AaJQ4x z*AaJ?=18@=$(QsObnOzr+;i)yvE$gL1p*(-_G`D ztG@V}FSdD-pm4X=s_5D^io_2Atf#y0)2734L!#AAGb&#SX(rRLqP< zqcIq!9E@Z%7{yq%e@oAPz)0GdCMcxk+Td)>@;58(oSpdV z(kP;xZ(pA{)K`0}#dPIo^_>A! zu&dwcOuEAphL?tM^7)$kg}P?P6B&~CS#IhUN!aPVHKFliowaYByi$|lbU5YE^#r~L zH(eF`y&k08$?6Zv)}rroI#c4EEw8JW$ira504e@q$jb1UW7C|g(UbO4Eee(eY9%pm4zdDNg#oH6amcd!FCio6GXHC+>X$Vq{0d_W{jec%>=plQp~1$M+-%(i3p-}X&wD;6 zxJPKeozE%1iTZPHeRP)2e=A*_*(Gz$yCiXkY3cOEiLcJQGrHxyrTudAf_1xACt~Xa zRmfg?#)}ufu~ro;N^h4Dp^T><7fhV}@RLz-SN3OL<<4orlspGRe}^4SD{2?SMM-I& zcD)r-wq2$+ilH(4lipoT{e%8{RQaFU=~x!?Cndkpe8BId81=v+i3dmp!bz_Ca|Od8$;z$iDoR$=eD-F*g4Zz+PK;*o&^E zgkvx255U3#a3V@Xc$HSp>Rvr2QBi>pRA#A)h_)M+C>+I;tWotbUCurpGqjJV#Ka^} z?BJL|`prla*(MP_nufk7iPKFOW=f~hXjC&g4X_kQu<$4iMgK{X?$3y&y>Zk16fx#8 zl?{OuitYL&uSm;LH)5JEym=Avb)ACL!?y7WOOy^6me9JsJveFWp>aKqaF^jLl5>7H z#ig%jPNlnRZbd_?>%1Z-!8-$*Z5tD_FYS!CUwo5w_iaP3@s@Lb4)?07EFS92S*NtE zA}-$N&4@LR2N-MON^T?ts3tos$uw2C96yu)(CjI>6??-C?x|>49dNxlDdg!D z{opqa7EddM2=5(BH?_`OuI2SCZRf;Z$4e&WrknO9`&EqClzTyXrH}cEO5p&$t2|UQ z3sB7rOcJ3ASt9WpnIGeW$1vRUOF9VAttygaG7$G!n2dlh_wFE1B=h4H!*MW}MndG) zKr7Ybs@AfCM}>hCwo_xanjg8Pk0}lok|UADR7HSWggnoKbMEhun?xl$(Ar0PU8kn( zmvN6oyb7j2-hz2@kedtUggKPhmDpri{dMFvxZdMnX@|hd#u1x050L?4bH*GodtMw6 zo9TZAv7rrv_6yYdGxbFx5~iD3F4l6aei>uEhgLWDrG#Phc9;H_0g2si6ZCJ|Rf&GR z@LZo-uF<@}voKxVztY0c?NHfvpW=?#!}a?qKcG0DED~XnB6@3o1aQc+42VMy{RES_GOb>K0Ys> z=5xP@1 zwp||GwMnVBM2v)^l+&qd?GoPiJ4-)zI!RSA3%_|P7%Vu(ub$RkV51%0xO!#5x!hYt z>bu4LihIg-XU$n6Hdp^}QUpO|ZB?(r{Pzk=#vIJPGTjj-5kMhzJ8eZpfKRH|yzC5e?a*Zvy?BmwR)w6Hv+;jA*$-3OB<7l8= znKfzZ6tTyAdY|X!W2O5rtPw9Jau2xO4p(ZyM zwM|&Ex-^JXry{=ROMlT`;>FRf-rqj*H=d-3^041oJvzjOSJlhz%CbH7Z?b`d)V>?Ht z1&@7QRy5W~AXzE+oP}zX8oNjItlr^EcD0=!yB5}UY}uZ`sP{NMPeVp4Nz{DG@_92H z?c|Qs*4DVsZrW`7Ej?8|eUm&E_RLmhmQvHE(dw7&p6fn8+~?e^ckLD}-A!wp^O%4c zFMM8aeXxGx`SCFgEbRmV=~qeW$BNh|w7vK5nQM_#niRAzx>R=Sv7JsmGBE?oXpwur zwoPtYu5m7`VWY}Y879d>zk2%0`p4>>bv5Th_N939U$ZgrtXxx5k+Q3{WNo6-?Nv)< z6Gt1;whKj<%v`Q{tmJjZdG#AFRVSU>@XF<3KQS~WM|5FRc+->U7u(idq>lY2aeAiT zE%#BSw>}wevND*e5OGene1OWwq7N!FK!SSfIb=&<-((OIVK(xyEHA3-eLM zhOvjqz=IuPAB$2Yu;ID#h#2I(NTvcYxFkD$yT)pB`2m)eB){pV=0^FWau_RpSRG>2 zI4rirJbnBx1#Evw5LJq$8*r(%KQkJnnwXi<%qYW;Utq41*+8nf&6@FLGv!I+o7Kxt zPL4SFbw<%XW^A1+D={}+yi>4FrpDjP0c=xG-4{>sB4Bwggo;x)&1`IX? zeC#~g^kw4uv5)O7%jTy)@NDj)MBkY;dIfoT-h~O)B9)&;Hji9!uu6#8B;h}==+T#f zm4ap}*J|RIuCVX1n7e)Z%}o(j#$))-mEIGoH)%Q=5wE*>F5|bP)Cl!UpT|3;oCO=~M(~XRc zs55?ArM71Ktzy&9*`C)uxYT__;e^Il4`&QtBEU>VOGJF>d?^ z{HE4f`|EOszWUvHwTkD6S{u?pPr>+|+?d1j>y63^Ixkq)On*B5$cP<@ir-Xcew@9w z;ettrsd#{TcH`*W)uXg-?rIQtynT^DaLD{ww(=$mB-~u&(x!H-e>B!VsHCm!68rvy z{E?MjOT!%IyY(r!MUxUw#y%1EFOMS%yV{mMTC%-Yf|4d^v_G=(anKmg2l__q*9vtz zx9K#`%rmsxS@J+HsoT}kdw)#5#)-)9Z@v0|5yXno5ZYeL?&YeoS*pXVEBp&3JdyMXbu{CZD?OZaE%GPLt zv{QqyMp7q@I!M|BONJ_mKp2?iObq2ClVF!&enT&VH^GdPC5OQzgC-R-jG zOqPy(NCAC&FCoaj$E?NCG~z%;h2F?h!gJr3u*I!_UD5#LcEvDBlu&!>CvnYb4li)J z`@54_6uPwNZ{e-#U|K*|0gqH|h_`}1GdElkMFEKbl`D=i0n!`;#aYBw!PS6y(f=dj zsN%`-2lBQVk}uX+OtaFvaL|AJc;|kJNbg1W>c@$UikdJzcZH&+z-5oXguDBSGp4d8 zU9rkapTNKOn$2%D3$8n@JT2oIIDMn(Fy`8~Z#T?_V-{ zxzh=iarTy`Z}uD1@2UDIkLhOEl*b?55L+;|c%@d$MYCgWiiUi}`(KTlQMu}^v88l- z@7U*_W!4vIBeexPw}r5FlvlhZ-2OcNYB8}kuAD)3NI7z}A-z>6f|>KSEg?_#M8*|| z8`d#*{iO7HG`b$p=sFyRh9(j%@z@G{e1j|BO^7&*;}T>=w(?xH$3Ws@uid;52|qzw zNB-{^BF@pwPEY=;?42V_Oh(s5Z9kt#D)@bF?=R&>F|qNubPAT@pil~}y#Vy1kD2IW zrZ`h1h}TuitOrC)w1`O(X!Vz~eoUKqG6IP#Cr%9~+2d_GUZP z2>-oI$tnF;pPY`#{cXg@%tp@-jUA0T9}?!hoTP1+Sw71BU07CN(1iQGM@!xZ{+7|e_G}U9)CaDD)kKWYGyP9TGGukbqd6};r-;LcWMRW^U;;OI-YpRpJ z_Am>AmyCSqYd7Jd)02CN%ddQtC!bfI+wV;5_MqJscRP7j`mJP`WX6`Jn~eu7KlD9b zexu**U`y}8yyKUNFP1o)712ai44h2qs2?%&Qjacn)Fip=W6T4!yO;g!rhL*XsC@3k zAJiXTbNz8#eF%LW>AKK5fp0-QF0TUCKGCaVyuLK4b76!+p5^pAn}m8=Zq%eZ2Q4os zd6~Y)@dl$N+-jhMoE4`ay{NE7!%j)y`Nn(uh0~T^ueeV>Hop7@`%~*;_Y?)!Zu5!a z1fdm#?q^x{4_)u4mzAm>d1c5vB)RUnghk7qoQYb`^Nk+Gc5YuF?pEyfQhLn@-It0E zOCK+uRS`em*1&S6;?_+fMj1U*j(8lO_n;&HV0@}bud&fCDLt1hftWN!={M;@Ey6%M zlU<-5 zJJPT{IyD!Sth=VE3e57oF|u-d=KlA04SVwAd~>E7J!qY{d+tZE!1tX~ezVbb_dKw* z+E+Jk&ym8qK#VPz21q=Z$1jn{yMp6wz8@9~#>)O%5I69&If#4g5aRxQruYyFrvd^u zrGfPYhqGdgM?s{AI4l435yK|^tV=*bx&$Q9C4fD*tLIakl(Iq9t>~R>DR-koz5A!B zZ?+vZF5>wN&z$2E)%I$Rcq()0qBVhI zBC9vK6hEIc>q=XZ*Ip65#_HQUba$r-SKnMa{d}Mj|MRey!as;;uPwFGRf^?^mkO=XmI$DYG(~$w=8+5+bR8)q3@Zjt7F`*Zoo}T*f{XKUyN2 zd~}V)>(3p!Go;kqeRRsw;vUM3Kj1R!R(H2u{*v4C_s-86b=z{!a{p&JlQNWgOAV(# z&YPgWn?CLI0n4wntF?RhGwH#G;^`np<>A@MU9LLeTVq6 za{B{%E>AhOe9h7$$JG-w14ioXZ`Rf^)hsldXnbkGo>jY*HMZ>t>k3kv`$)%SV?cJh zrvFuSSIa4<>U^!n@b$E&%{08O(Glw}IoUC}_560p}WW0JX zIrcM;Xh@Obmxs|GaQ44rKK&$j7_Na4r$3%V&9gfw$M5mz#kRB5R*f7Z(3F7FLX8Y3 z5jLsBy~H)k<*)PoVf(_q1=c)Bum(?}0E`|$qv40$EZ*S;husv+6Z7E3;jpv)YZ8Dz zs6PQ?ZAP7^kXh?6)*6hJKgfAA-~*Ztv*I;JA}Y}Ts5x|aGh;&HLANA43M}kGV&mbe z8--a9RzSjxRB05IVG67PpuUO}dXegHDky6sKt{I5vuoN^HTlBMAmE<*M z?a!I#>@8B#G~UWC+?toLB)9K^7Rhnk$z@W9x9s2-E9#!}X^ufb$vCTV5z|~k)P%#M zXB4h|yrl2=%D0ZX557#e+`xDpt+~6iTD$x5{kIa;>vh%@x=UDy_6p_PP-~=(Z0|X( ze{trfeJ*AqXGBh(soLGS_x4@+?8y$(OlkA9l@{;m)Bf;4Z#*TuaPRaSuq@nmAfeHk zUtlY7oQ@^iO4dD0^mwiNyGJV*E62z$bl8^EX+18qywQJ3a8{#Ai1E6twmWY>^eU8Y z(0vM<3aab5cV-m%Xq(Mh37uCDLJhmty)X4! zdy8b?q+`QH6(Pt;U?hC)J<6{Pt2b{YChM>MvL~*=hu`-L{^^5@!>9Vi{cYH_umo=9pgbtT<2fmksleAJ{`dJ; zhJ$xmVKQ|znWC9@XZnY8mji5r4NmHoO7C0fb<>A5QU6?4*YUu~RTtm=d-AffiE(G@ zqO`V7c&yTubmTqz^SQ$jb$r`B`o$=lvQ;Qn=C73lXF1VrZBE%AH=lifgVfd5yC04m z?Tl$VLd&!sRZx>2BUsaD^~&L$^XO%A<oAXiv0ga|=G}rYp2dbVk z_Dkii-k|dNTTAKd^o(5(jb|_quDkKZewC!vQz!~^db%+yGr+MgS9P<}q2Xmd=$ zqDJSuo$(`A(yvl29}oD_Tr5tkjb9zv@YwQQ>cu@hch7DjX|`QCvdkjr(ufC_Z@yc9 zx8sZ7raALB*Zy|Zha{A+$M~+vnX#u^o8EbP?7L9=@Kvvb-9(A3)|$+dpBh^p)&?ic zJ##vylr3wBv1N4!Z(V$Rz^srR1!*G&Cm1m+WQ8CJm=k);mF{(oEp%noxj(g&kl zV|{xEN7KKk0an76I0fR*d7ywdokz|Kv&P}%Jn4ti=ii5%$GD0vCK#1Q1$$%$QgmSe zIS)}I6vY<&Ef)_hYz*h(p)z#w_+C#CT{bXSd_NQO!xe*fsE8j)mR>fV()C4l-MdeV z!`DP4cuQTc5FxNLKX)&f_U!m=wC1Yy(n zVD^%40<$x`?Zj@n*P9B}+TLGXc_SY4)nb=Bh+ls3&WY7>Y)l|+TA*X^G^Z?DhH664 z?ECcoS@ zCgR#)`k1jkjgAwt{{nU5->Dmj*bA=!#m4ed^_be1Tbtie zk6z+$-|_X6ZGMrdzsG%y_Prk1_xZ!WG6%Uk|!Zt&v!rzeW$YqgtoDNdXhvT?q8RAX^@nfa&13)jxgOW7KA@@4SO0^!ML`iU$vapVwh3379qu}F;TC&eT#HIyeI`*g{qv}tao%QoXWnTN zpSnJ6Y5WACCx!Yiav#zSWX8TbZs@J8-rrQ|aYv_q&yKrm_inQ-J9kOZ#{FT|$8j6V zrNgkRhZAV7Z6WjDtzTw1>a2S8^t#>m?9JDC&bwK9<@D5!@CUvpS|4D?2b!O_e-=OH zKk4~KRYg<7BbTP}8@v`T@nqb2Ev&74y><~pRp`(iBhyCofYB{U?LT4$gCE3GM4=v1=UOcQ`7D>s}DM z>fvH@g%)_o+}uoL>q+IknXzxLy?^xNcBbu$TC=R&8s)h{QR2Io?9uIDLL=M#{k z#1X>;0X?JIZk@ipLFM&^=7GewuY0?HGY|Yu5b(?6>VIgX0t5!=dm|ea&Y=RL0P4T$ zQ2Cv@f0P0Inf44W7yvVtXv#)$n`=6q5$kgZPtrXIEv=TK<<=@@n~ zQzaIz7?>lq&C{$aGQ@1ou8HNgKKF9(eLh>AcVGUifYWNn%$ArBmVKVLXC;@%lzNv} z<=1F^b#r<@%Q)D8v@y9SK_c>v+ME|@0X{ivHMWjls#%pLbv1^t>a4p$u5EbS*%{__ zUq0JBzHV=_Esf~jeeGx!y>P-pk8^fPHC1v|QD@^bZX~P|Wv?6cC9@~;LX^ac%^Ad? zXDNL5+78MIT#)}_BK0cPA#THZtEm)g7yrfK6P6cZwWs7_JfmY*Hpz-L7AoqT+oNa_J*N54~jc@wgT%JyU3W3h~d{9&>tW+C5pD&*v`1G&F!~f=aRc(UoZNHv2T`u^uy;vR5JwNH z>EIXE5)llPI^g^53LSx^ys%*DcPAvzfGqrT*Q(DkSI)~yz0Z-)KkK19LG7D&Td(HP zvM8!<{_1zOl9Nt<%Qa1#u2Yz}h^A3-r=x^)eU;5E6TR7ouLXWfH5*4>n*~EwbW8Qff}? z3Dj>-_t{KYDel@=}bjtb-6d~jG4>}{&Lmdidd}Wm7UVSab^Fy^Y1kttlB=3*kDzDOKy|2U#r`F!>A05 zb$eI^Brz)M9L73>u^KVfcCy^Bwk%u^fE~7F(Z3OlKm$#rHEiH)?`EO7o4XY|uQ2q# zUd##{zAxc~LApJO8LKKMu9^`SakXZ1vf#8r)s7nrj*WfZlToB|_FnJ=+9FcxymZ^H z)P&^mI~Vp1#GS7CD61n@*?(i)=FRQ7o&*uq%OlU&ZJ6_wFSeQ9o37o->fa=y6=gr= z%V+f$=}7}IvDLAX0@*2vn6ylb9S+Eu;(LYqGu!~G_yBxFtxI`;3IZ(HK*ew7U1VqHnTNy{WrqJ z(#p|=@L!0%3m>titE(e71A~i+rJ0?P3%!G*nf<>Wa|dTTBiDbY&K3-gMkY2!7G@00 zjEw9I|JeLL7{vb>lTg*m(d>Ugw6ijCc5rbpccnLRu=^ii|9Jg_V`5}rEH|ld^X;b2c|JF>|4}cXM$xGa)9FGUX#yW;6NM#>LKV#B5^B zYR<+)Ovv#6hs6I;S`2n(u12Otu0{+d4$fwDj?Vw0on5WWT>dAD|M#T0m^r&!{bTw6 z8N0tETrWnl`*;B79nP^*Ibr)ssBqN^SWMwg_uPd=)`k$j`Fx3eHcw`G4T~CantnOdj}NYq z6AAeiJ5Za)eoh|wdsZ3pqYaKfD&8g5VB&U|6f%X^xrjmx4QfPoanJN^;3ezL`+aOJ z=wfLY#GObj2zckNIF+GOK&COp)MDpvLl!Ej@f&lC$nRnEn8mxV< zWTW?(oktZzj!3BG%;Ow;$(nq4`yc_ej4Up7pYqY50?}#;GAAN$R-WKp9z8DlNIa5E zeTi4>=nTmu*zIw1IS~FYa#%F#of?0&ZLv)>jF}H^9tYdn#$q;vqfyKr&$~W?vc6X? zq@z)e6z#7r1#r|Lifpc>Qp7Og1$+*i+$EpnZ7wCX;>h0cOWGhMyuyTh7OpPbTU-KO z;5hlIOuU+aLuv)7joqCqBP=1N!~tOE{4uo~d+Rc%R7Dm1bDp zobgNLmx4~vr_Fx6@Mr6mx`Z<12zmy-vKGwZE#wv%x~!cJKFwGp?%C!?ghp`}ZVOpIIPR8X^I~f@$$hoBV_LmHj3q^N$3>%)xm_gpmm6ee}#mmLj%#L2!%*e#m%H53qf4cfi zZEgQ6^<4Qv2&%}mUd#V}seB}yC%T*!I@7BRG!!BV1wxV}gjxa-6;)DdAPSa7qY>)^ zz`>~Z1+NMURhLIpmL-O*?7%eSr5aOhrxkx8&-4ck3BxKf-g&wlOnHLwj&3-lE?{g<*uDFAR zZmp5bR?<4}J#_hQ&%8R`oJFA{2J!<-6(18$7*%)!fz)04UTW+)OKD}PGJbAs@nWN? z_NHbib9gM%rOQp-uGh5LDCMZS$3V`;l|`TFdbAQhI-khi2ehVADMzl@&}D{j=vO1x zFQTTRt~(mUw;h^Hl@4KvOiQ4z44z#x%y1Lvul(LT+5@M_UF^PFJx<#Smi%g*CUX?* zeCzvM7K@3;tFoykomN*LIS*Qn!TwY`#buqs0yUatC*hW1q8JcmS&cOvRCDJoxD!S! zZpIAm5QHSUBVL6`DsA405^d=n3Rnf+0>CzSAgk;2_rKUUa6em?+Fyv&! zN5K{oO}P86whNEtQ0^pm;AHDVkU|C*(9*}9_<*{56{O|<#KaF^MMxUIiXvQ$YY#&T z)h|Mg5GzNM_EW+J%xk7B7d4@kyeOUriC98QvnX}IC@Pg>cpy)>)$1iM&Dx6CkZE_k|T@FQ!4js7E1mS3+E+`Af~`q7E}U4kP}qGG-rxV zQA!ySp{CRx5;>>TegjQk_B~sA^C4lZ{dmv&KRQ9#f7^J*J0 zWR*|?E*J8z-c(oo;H>QLJ``ba67fBSxgO+1Rvd{j8cqcE2N4Gr9-cytueP`0{S(i% zJHqwp^kSeKaO8O4A0Qo~#ErlJ{74TYE{uNbCTtS*K#8S1 zu_+{)QB(q!EAlLvA|e1XN=Ofr7!wL)w_FeqXf5;>_)F*)p&KwOoFaxKl%j(rbAd|1 z2B90gD_%-;h+&_Rki21+ItV;?iHxFl&^&sI^zSO{1}4}XV(C<&7{u&A@CPIaslYcH zDB2j>dP3(@{d$;~%R;?XwLs`ycc9AXD)2?5h+8Mkq1H;_1L9YPz~_BNLn5kOaHau4 z5cEZI1WNSLfuJ_x1P0h@aC}EmAwEq;ldxG`;=pkrJVT)^^AdNak&(uHtOUQ9_m3!q z?Jc>HrVxY}$0G=N0>cPRx1}9%xR=tAQgIcUBZB9(Y^_0<5~NG(t*BHBF>>Y1#FMF1 z(V3|E@$X3}6t$v&IzU>_%DQ?}+>BvlBC<%~gy+Gh$J-QB%3{XvSe8qX_TN4r1OJ zPnm+oT)A%*UPA@-=}o!Au;ZKH@113S&#wWSvd@C@4LnNV4oR9Tmq)s$@W6kOXsMb* zr$(XP8ZsxLR4D196QdZ(6Nr2|6`yiq-@wk2;<@4*z5gU+mZ6F6Tc&`K)lbJqZW1v*4MB zR8R!d=IrmWQ6{hW4NjyG69>#0e;aCpuu&$;MrFr!hydCjR{I;mQsb_8Ea4he8)iJ28~ePLGUzL}fc6NR3D9V3KHYtZ}@kbrOP zk44d1qq1TX^D>}ohymS;C8Fka%m$ly@2~u($izpBchAE`L%UXZ5dqN3T7!^;aYuUs z*O`%y(!~kOiS85rjT-~Qekki?L`FWSu+^`LTvu8uqfqvW6ORD;+f}kZUs+&}{2(>1_S}>k=a4j9F%uF8E6R`=rD+HcH>jcl);tFVCkLB2ag5s>vhbi{(>q6# z)>_!q*PAg8PXTX+bKJe;52Y-&_ETL{!Pi_qBb`hw)+Vaq|fXSR$65tH%RPbiNGl&y!fU;?Iw`hRu z<<>qw%H;YhMy{xyP{Z2PSr+y!BHY=_Ft#6m(BjHVPwX8il;!OM8uRoO30nvE_M1F`iPcO9_STQHZ!TkcAY8DPEWNd+k(*xG-gC!EzOI^%=;#JIY(TU!kQ zMKB2oqr@DLKv7Oe6OuUS2nq=XO^B$T05>=eyaS9nGTMikQys}oT2xF}6|M&1!;uFx zHV`-}&oKy&w z75Mi|NVAw9R+&ING_ap?6x$^`22A%?)Px`?$SE>ILbG6&O$Z`SC>SUf&^Zxef*}(o z6>gx?NlDCZ5UW(EAvjQ?ltkfxR!JX*5MCLaU~X_^Be0`k0t(cC3qq-!!7_ip`7o`D zLbKjNuEkcRJE%{ncSZp^(}e#*rkm>15m_1TA(}ob*JUcvQluUS&j+1+J-x8PN9p0|=*E(+XR8%dQT4I&QgzQ*(v0vX}z0A4P< zJKy3&=FkSz;Pzh$4-_o$_x*zSMNnX^tn8@(ZIb~{{9pvSBq{S!6iQg`Y*`UmBH&eN z!;t=9vf1Ho21sPkJWE0})9467JlNthnIc9kT5;Cw-F(Rsl;DaKO>UArB$1*&v4U`@ zil)Sz;y>OkG* z3B!WMrJ~4lu}G5Z(|3M}wRF5@K_Vv)E6U^NM;GsV~&S{p%^5 zPaOVxLW=cF0HW%chiCN=NeBvv{NY|;hfomVG5DK^KadabIsE?ULTtcS91Q`?Wu@V` zutI<@S?wcmBY?Oy&Z?6KIt$oDzv|=?#PMZ7k>2h&X0}h!L4Y-MS_QyXGz&4R+szz}TBMn?aiLcG+Rl)zR z`TF>|4QjvX{T0xe{(bZC^B&T3FlC5=wWpiUX2Hj~+r4)lVD@ z5}w3a{Rar_12P&L+V~a|fQBBz&>T@VfbzNht* zoYud0u*wFb4KI!v+w=PZ1(9ex_$K6;?3dkN!4d}=aAH(8jASa*g#QJKSMeB~j-RP2 zOsBEQdxXq&&!Q7x&{HtqT%0LQa~vi;OMI4A;%`7vBB01qC#(PUCKDFhVtg@{DPD{= zVI#YgzBAQi5#g_?ZH47JcgA*wXs07Q3iDp{#obd4C@&U|lXsqWmV9u#oFsGUT4sIL zZ9VOB#o5MxBqOnx0qhA)VLr#bSV4?Vusdj4&Z0lap1od?q@=5SU1As+bWK&;C39zV zdwL$8MS#o{*<7kOL)U2dZRC8O!h{v{ZXMUC)Hi!OrkI#a+gD|^&Q|J2&6s_Zkh7`X zRG#HHV&V^3BNYpbOeJ~OJAAZ6UOsUWMD0tKgcoH4&?dJN)3TLu1O8eFwv4TV!W>hU z28Sd9VIu_{1=24y-R;+x7cgdwf`ABf;#P+|=L2-^&=5a623$jro zuEN?7j%mL})f=aMl4X`*)Ui=d59!tuXHik(Kd%v20!I*HvEF{yGhFJOtDPrapih`n ztY>8?X50;h&MA>7V?vQfIkAS?B#m~bn`8zGfukVE@-Q9@7}=PxBsEaU21gO1@cJ~x zVZv@BJO`D<8DnPK%v2Gxu|0XHDP{&xXMZg)4-&EbEw~@7N~Yt+k|9oAkUq}&;x2G3 z<(8{85l+a<;5@uEq)YW+kfs_TUU+cah>7j`L-XB%C{pKg{dfZ%j@&smw7hv{^YT(XhRt&Yh0CBS0!MRJ49!e{X6^TUz9 ze7+$H5q6UuM-=8Bg|j7pI~j<@hrteLwwLzoiLX}a)UgmLJ9Q_?23Pk|Dfr%f`%N~* z-UZ)l-?aZ~5Vz`O8l2r04;=XvOK2S+t<3NN%F=!@_-kw19TuwLmK#|!ecH*4KKn|a zgLr0_uPK*~|Fx<~Z?4NV)I6t-{3vl^X+ zKF26HJ5fxfv0CM~^L8G}PUK43?GV~|-De@CLVyzRPMfv!wLs4Qk?q#>2x$C0HD(G^ z@v+9ACG`a%SVkg)gxH*fc%paPXq>gFKh-O#TS!(jBRuJJ7Ydbp{tH zI#hxo2Vo`dv#6HM>u4R;FZ;NmX!1CD>%Q|m^0GdKFex$nzH=||DLj=KNlZ!nHQ0e3 z^NWfz!=^g0A~>jm+HJz^4FQYBp84Gz7E6?oMoEP&c}5jj1l;F7v$7&!M)gab`NIQU z=hb65=E)Dq=_2*>C>#dkX-Y-X8y$y>(zlQ7PDjfs;S}PwG1G-`_B$k$iWrwpe2E*cMJQ~?niXtq@1mBmP0ZWq~ zxpG~AC8>US%CvT)c6kX7CKGDD!=k$r^N7a`2bs3Xm>*|riJhOfRbOv6Dkje_N>KV7 z=gJ-!p(ND4uEflv)C;E5M*C8><&kTZu&eW=VDIYS*F*2Krfl0Kq5pS}VfIe=7-}%4 zle1h~OqH$ps$W%Ssy!Td%b(vd@4VAu1`ae%2w2ZZl>vl3AIBfrDiZ{(Td(CEm;xf) z_WO?gsb@<#{mjUmzp6Ek%Ac4Ql*DT=&MYp_09oKliEi9p7ZI_AjMCAZjOe6fL#+oU z(Xnu7W0>rRwFhGd7n}+GK;j^=cyw9fM2!_-Wv1@5pk5v!+Ekb=>?E04Nw$-+L8;6~ zLMmY2$@E(WnOR?xT1L{2i%`vUNMOM(O45p5-O>~X_az)N2R&%i(gLRqW(-RFmde)L zx7{C2jrq%RwG%N>8)4h?dIF#Js&Mz zqkry&Gd8-{{oD~AjbT!&sxqn*I8fMm->n;hwAM3`YxB-qOe>m=d29fEi5Y#Lm0zsM zJkrKH%MDLHDzd>h6N8QX`V;Y=-ejkK5h0IwLu1+(HU0?g}{04vksX-8D>X)z$+o zpEArg!lilZG{}HXerxMv;JC@~l7te9h<@J@m_E*byW_l_ccD@G-{fHev&c@qc5gVuXbhnK`dI z1?2@WImWtkAV(0l2K?>X8Ga#%g|JV1t3p9I#${t%0(Yi%q;MZ`fBGG;r%i&X;50~= z8^Ij2*yh#qT#j3;R{xNM!)YsIu78)(9^P7L#_jC4PP4>oK!S$)Gup}fo2AutRi z8@$Uh^&I_CxZEhQ7%qmcnScRhx3HStva#5ADfYFHlrq?#6Nw{O$nMG@xXkA<)Ayz1 z4|1=l3^n}JqTQ7pMLX!RS^<#puTd!hs-V3bEyFxcXT?vFI2;Um&nK1`^SvoeCkzvo zl|!Tf=kMEa!qy_){sbDSdcM>eYP&0y&USDvMMBEL4fhgD{RPt*6UjXh6?#+#OVynM zxybw4{9of`7HBLY*BB;Sx^e>%H;bFQ8S}lW_9;G(!Ox}|?Q?hPB34r8=Y^d&;{p@s zk%~1OU1PHu?o9_qqYKYXawvoJnv~%?26e~H>#wi;E*eW3^U&k7n;+;dtabMM4ENR* zhtxk{Qd|O^VeffllYrJc36Kg(!Io%~#Oq9NzrOz@`XikADP{LUP$FaGA*qrS9m06g?AL~}ez-=x?#K_gz;!1BFhB`HSc`1iNJ5V!>VjC(sU#MIriU$jpf8sRFP8M!#@tQDSV z1Ao+R=bv(DovTT>Ma=NC%O-dcxw3c`1+V-hao z=Q55XA*T<^%By)@SmQ&0gZ~6&>S4ggqqOLXR%Xbq3px>JnFKT3u@olrxxF!{uuEt-1e<9bX4T`s*FEadtl)Q z7NGmLgpGy0l3#iF*p?5gou%1FAL?Y)_JNHkxb_2|4@3y+^~a6Y%c<1&XSP-uz5^yQ zt5&p+x*?;N^8V-tL;QSnBr-v$H%h$R<3YOPy_7is2Na?h4Q5!0Ps*=n*J4Xp@ zEXyC_thTN{`DpZ5Y_dUczZSLJ^PDeQq_VE)XJGU3@SeMDU5h4ICnQGtT%2DoPl)O~ zTruprEhj9em(5_tyQJrMl_t4LaC{5=d-U|RpxYDm$y*PG?Bj*BhF8!^?>>5;WF7QM z+=x27s@9p;D64awuBzE0@U5OXmh_5QOTl3_9f^NkZYgS{wv_#LRrzy&H&_guz>;k%0Ib+u=KUS91RoW4HkL zKr)sT>Ylw_DKLVr;9ZilNQ z_PJlES3$1Sy6pSMk`JjPSJzbZk0fQfkLAbR7EgRmkOICRV5CKMqxwhAe9LJo&*ms? z5a!vzgv`S~$K^GARWvc-QDr%ojV6EFZ$&Xss&FRbc*Sh}v>^_~cvJUb`JSk>H~JOw z9vi#DpNXz}QcSq%;+9ZcsH1(`Z7u9eocq!3Hfm#^#yeNl2ig9HXH$jbj$D&V;b!p9 z0x(`I!`Qx5%!P+QMjN?BW^8BX;#GNfP>{h(HMfV+P|rnbrJV`2&&%3I*cEbB(lI6E z6ANra=h1?QMr0`rZ1+o+b+O|lTkG&`;+;+q`tg2GyOZNbZJ&B}(@Xaxl;<5Y;2CnV zzcLn~fG{cq4T9Flb)5cdL^qVc{_6GkOxKh6hZPMc;4KK)4NwA^P&`Y+b{M`hiHoac z@xv?whgYk+S?Eo|wYYUBjUe&4xi&$O_hUMkNM#(@js8q(FpGPRs{EizZA0B730LK@ zg-5oK`IZnj{5<0o)uJm)d^+j7v3iw0v2pX0i=M><iRoi1`-wI-K?i|~o-4iydXbIZW!r$|v zcnM7NX;g=TN;C|qJr9!_J|4UZ7XD*z3dQ;DE5ad9QXus&%KVEfGrH(Yx56}(eB-3n zt7MmN(d0?Hm=`(&4o}NuSGwkSqGKQz$W-4}?Y<8R*=F{)matFhhKuX>XFW?y5INm< z>!cN*W&}?e+xIFgimVZGl*gM5__tvamv@aYGfBV6ZNTV7dD2;Rh)tE;t;WTrIX9*r zH}A^w@NQ4x&xU3a3(3Y$mWcf_YS0%)j`}iP*IC1H zbv4J@1$6+VlQ6jx~Xaa$$`n@u@19urk!Nc=+%`-t(SmUzs7L1Cz?%H5eh3tIl z`PZMHgG`RN)>aF+r_O4~?@FoP0gsc4y`Byij(tU-GUPS)oF(SF)(&6CKzE8?JqpnE zMgSG?i_^5BxOXxe*IM0XuDv4DU>dI5al_|rHwU^aGw+DUeDD+=eYV_knneS-v28V_ zC-e?JW1nuYg}&>ev4sm0RT{hPN244wMMCAT34XeSZIr z)3uE41z=~N@DE_}=jUDqdO&JwD5P|8A0~+=!lF34W4!JO4<+L-5fD1&Hu?moE)|!C z=3*o_;QYL{ytHo9kR*nAk9;x!6525Uh$gG!m@VR4Cd~OhyrA&GWe@Em_5oV`3^%3z zHNkMcVRH*G=;8j_(dEgLYuAPN93BBFs=E;v@iWZ#8uG7AO=PoXmVa-O%+7J6wEUQ5IC7+O!)x#(`J5p{mAx}}Aa`%@ZCx+&oKcHJI=q$X=q zl^?GtEoiwpGkBRjR?*uGW%9{^p&B9#`Ntjnw>|l4`lbGtsZxtb6$2JY?i%M0rDwb} zi~$*|y)M5)6{2QfGT~5Q4Jg~`d{VgTqMQ3NEd?a3M%a}ea{BvB{3((bjM3;;dD2Io#wGsyDo6&9Sc!ELQ9$y{6Ib#i=j2W6|v{ z#|-?PwgE;fWE$Cdc!1d6FtycG;FXIdJvDdSj0$>Ah9;N&?OYjzu3j5v%|6(vY_shx zrW*5aio3{{uOOOSS3gkr>vA|YU7Y}17ZtEcq;Vi|UgyUiQRgeRMf(H)mW{QEA3FCr z)bRFj#h;rT?GZUnC{0@%mDPc8pGM;-VdU7p0Ndpu1l-_A|Q{rA^dM z1{i)E66-6Uqq9MoSsS@(u={ya@T-23v)WiUZlsN3x?eqNn_O%34MG`T>>Nz@ zq$d|%$Y)9u=njz?xCWh5Rfk%aT{e7wg+9dMw5=U(n5)MSE4rJlmj6PU1zF5dDae7k znabr|BEehQIP!6}Uce%ycTqfFm4vpo7@0*6UQ6I>N?eslXcb>kmPle5c zn`?TfrhlVE9h5j%jBu=W)&a%C_jq-+|zc|;jacIdjUu&uN*NdxEf2utN z{xkd;;jOPTnEqlt(_MRJN8njXwP?g_Ur%BJ7?Z2%8ERKv*iyma7e3jAyB-5)c?;!D1m{C1KL%cBXl6|-dO$Wu3SXuURY$hDDja|eB zQ2#E&r+1s;A=!6%7Eg_V@;QKbA7LGkC24O*!f9Ro$UfSv(Bc2>lf83W+F^2Ca+h7l zcdFZCeHna4w%V2VbquidZGFEof282}5YXlSa(4OKJH-@d*HGL{A8`c!iO*lhuW&v) z&Jtna(#lnj(*Ir3Q?lKz|MNRN%Wx}L4F>&URUQ>SJ1je^Fnf!)XNn#XKJe?6o#&+2 z1LKk6e$DaOz4#8y*PSS*8+e)?Qw13b!k2s1sEM0aeD1RDd71K87`V5%3?a(`RTQn` zqFf-}2$-Rfi!FQ)0n$=N5-KWvlf=$gZo| z{u90XWU+CB95VvdMRX1aT}K*y&oe4pj-}~OL)cnk{o#gFL|Gw5S)d)A5)`}#9KbhrK` zdODGdn$1Eyn>CsH2!=DmEjanQ1b*#y8Nsesv&$3B{b6NLh>*5SeN;FkY`^DYx%f2L z{C~T@t@@9NlxOpp71yh*Z|$x0tCt<=W%M&N`{&dq6ddH~i$zPO+*KaW<=68ZyEuLJ z!V^)2{0)tT-k)c^u%m@7bM0*MGir-vgbV*m_CI8^>^J$T7%~>B1g5Q=(2&=Cn5Szl zxQD()f92UpIa_9WT^po1ubcdPIjK?*XqTxIwgqmuP4gS1Ho>RTm4`MDk zuibVvrFYSrn_M{UhOu}XfdH*HVcH8WJLxNoSF&vjHw6V}kdnSy6Pw8VpQ!3tDKjhP z(k!gHT+s_Wad-XN9G^;CFDFao$o#SmsS}vLR4$^8yazp{4gyO#35-9&gfjBPB)ia2 zMYl-Dl(0o7UvWQ=!%q<>96csRRGg_K7z;&ZUSzyb5l!C$egS3!0W6GA3XD8aTgi_0 z%~QE6&Xqbn{iQo}C$;Up9TIKh_b82Tj~jrWJP$3ZvS@2wTg&gpF_Fe={Q{~5gRZqt z-=}5vC>oNmLTsBDxc#JsE^^K!5CIB#n9(2u9S#}Dq$;)roP1RO#tCkLin_oxOl8y8 z*TlO11qifkZsK{>P9FiL8*@Yp*Aw!sjLc=;dK;skDyb69AWNjmc;y>f& zCZf@IZdeW3Zb`t4FR5FP{h1WW8ydA5W@IlSOWkFLHo z{FFAUP`)Y1$Vs}Q-F5ebr{x9-q@Btpd(9X|&62eY+QJe{m}}b z?N9=Gn!`|Fm`T#jx^y($*xZ8EQ{9B&-F{V;0g@3Ocys0qW8OKgMp37XolW(~DPCM! zEPdQ_7hwIFOjif_%dSCT4tLQLR{PZpOjH`OFti*%L-uwhn-aXNTTdrdVRPz{Ev79@ z1}&|58|#Oo*>h09Ck!LT>el8eY)cEPyPHevceX)bsx#?KA8tQsMo2!}`E-maPQe7` z$IfzYgcm`FWA{|Bhi|=!C^YpBt2GvZo zme3#u=dc@oi+T2;hL92m^(f(-5)uZCVQ-wUe7iG>e0eTQ0y|C%MIuQIg?UG1rR{Qe zHBtK~VP@VceD_pulm=dkRk6>s8zP&%Und_IFYbSK74hW5vPC~0Jn+{v{zlogVt!I#1;8m2Nx;){h^UoQ9i;EPSKXfjOTAE} z#BBjLa|dPHLG^^?9yhJ}S-qobt;@?2D3))w>C34XqV#26I)s?mtNM+4_vxA{9rC=l zI)8cIV_RYXxh<>?c6QcR6+gu{=vrSComj4Badscxs6K>6-CKYBRQT2Fr{+AtGWzb- zUpHetkYL%u^0~u9&*z<6V^IHFW^Db-woia- zmt29zO6$yTC~3#Rv&K1$>xjm6pWI!fjVb3`@zl)EAxwRFBZBIJ^`jGU)MQl4CQ zcNNw3+*{QRgSjBA!>ZeTafKa&lUnxjmzWahzhk?anmM_n2@A{>s>1$f& zZ@|p9E?u;K=lRFy=;Vh*Srppo<2o#*oJ^suUP0!pva%BYlgn|T+`~%gm1Ns<{bBMt z#zigM;7O$@$B{a_gGy~b4+Ga?iW=`&)@<<>0o$$7>yYs{tz89dp`4|(*Svi{nzC24 z#OM-pdW)-+x9u4BhJQ)N*Ha-`2tpZY)Z?U?LmsJYj|xV?w59(8;<=YFa;2`rN6>lV z^W%a13?D&9X3UsV?4sUUdZpO&IxZfkM@7uSXjdV-uO*c@pN%Nl4B@KzPYzEFGD|db zT0<$Mz_#rt?@thxlKRhooWbOG>_+Rw%0f}qP?QZ;@((LX{8FX7tJVpo)PuGRSD?NZc zcW6FGZoqPqi^I2E;*YGIY&*wKJvhh|;;Vqm!q3E4#o9UEUptY*^&<5=mwA_kg>pNH zQ%pafuTK$(iBx{1ckM2H&mL$e#Le}D1mx1^uk&OWZ1q-=UIV!os_Nl$Xu2eh+cV$o zHpeVGMe!&5Ff1de(7}?N7e0V$>q)Yh-ZGRSGKaY5qONW3)9`oE3$@%B=J@#+4YajW zvTbw71`D|+{}~*2fhx0r>Ac6v%+Q&AUPI~ScA-}eck7Gabu@B#`cU167ndGO94E6| zW!x!Xq4Fc0yr=u_d+%UFCRc-F_3(J5Vj4p}p5R)+lF`>S0Hl`E9Aw9ywS0cT z?fDtKc}0glK+gZe`}AnM0!hH0x_6`YJ0=?%Q-INXw3lQL+n>fH~7AVbN9Jx5n5c!@o!Hscdi3J{>_P& zIC6uI3dCB{odc_JzC~!nq22ttQKzhrLHMKFucqs+I^!OeI4}R_#Zm?m`FQ&dZ8Zx+ zUxRJVo*CPR6fu7c-IR;xu^SoAnej7IjA$olwH{i$*xnSvc5ff}@K07akGhlku3fS) z2KD(mcY{d31|Fs7S zj$C|deb={xxo$IDUFgaFX_5G2KeL~Z8Sta^!UBYYx;rQ6gv-tKzVejzXk{maqCf7v z+xKT}tKIXL3y#lGHhsfmJGQ@Dl{e-G9ET2Nmb2kV~EQq&(8Dl-K35` z6!>5U%rS7%okJ{?P6B=+foOsDIRQ4H3R#qF{^u->jAT>zCYraHj5sZL0>=AHq$I0A z=toe3xLUhTLYmcv>D`nHv7 zZe?|-J}$W`>8VPSb2tND9IXG#jVqKNFhO&Vw9zw_AmVu)uS$>L>wY{=JB-G5-Jnx{_GC>_?8 zT8ByEeB}q*3wmWI4pN+TwuxmXT*u1ILOc#F{2S`^xf6(OPf*bhlDu@B;#|Qj!OU8N&+7N<>aYy zz6&713(8e%B6+`f`+YU=(Aukd-fM33d1Y-sq`(8~Y}Rt_E-~8VfdhPL)vO)U2cWhG1!13 zoobyzL%e#tf~A?jw9iMmtW{UX_>m^BS8gY>Y`+#Q+KromR4Ww+UeTqUhlkOxy~?>x z*yh~2h1+vkM;%d|)9bWLrA%#1Ry~26uvH77$f}nf6K}Z683m`4v(H)K-pNx1*zvX-<}ohuvJh^&t}QRcWjEbuR|c3dN)w)KRYZiz^ERC6?q@L) zehaU>LS4E1b!%WjFpc0>fli~Xhjq|XPIFW>eHJ3h`YS><$qNqoF7TgSPPUh>9+a>^ zK(Gq`2QDW~Iobcx<)pjiveAYVa3lKz5lc`z9V;*YzWVB$%-s`P%0lwwZE|~)qeF8~s`K7^mbu^F)~2_vd^m{Hzo0z**RfdIh@2Pg`7`#HCx`_d^as)ec@ERpQClyo(w zzQhd0Znan$C`etfP4`c6k`~mZ4BHl@yy!6gNb$Cej^#wM>?&xMYRI{XZ1mtQE~Hch zMq{C=_k17exgYKBK^U#YBxDs0C<~FA4jDV!pS~9jteN(GmBb=Bsb;7*qR~=1OMk7% z@Hi+AL;62tQxFVAnPXj}k=P>@31f2OqG`M(QsAG{p~N^sM`dW3s@pBnrBl>9bAtd= z1cH+HtHAKU!{-Jd9keiZvOc{);V~XWEU0{&Q6*Ul^$ad-OiXa!!ocyq&N+$NQZ&kR zBkU{?KtT%w*u~k%+*7&+-EL14q6GL6ZjHmVnYfB0&LezB*e&yd$;m{KLSj6@zb|TA z2n+XgP%Q6%_CgvmB*7;wEm)p9AEm#<1C0ZRbs>eBd6cEwYmx$>V(B9mya?AcZm@^M z>{N1ISby!3GUp~LH~FZ3U{mwV?LKTQ?eZg%^V|Q%^mId!6&#tK5;~xd)qFG?=j(%+ zVeanJYDUhmCiEv+(G|{dG|7pHFwzC~0P@E@M;?eKD;7C1oEzo(`l0|MEVBcgx``E^|KE6q+tFi#8b=m6Fg5prb=VXP#fU5hxdXDAe0 zfMyMYq%?i+)oq&6{C$S82!En>8EePIi%1kTWmr}Ew?DK(V(KP;lUaKRs=^!rni2*( zl?ITUEU#d6G$%htQDPM+Lo-c>KuzD+o6b>Fu*k46lG%`m2*KNxJV^M#aP3WTk>H?6i5eeHI#32Ctgl;6tNiEuVr5{6#6I&=q;Z{i@(PlBwF>!J8d*{Ssi+OkBI?tb}uC3ubz8;NEvafrc3h?SkH9^(Z-pbv7awNSHLWw)=4f?o1OM`p<9<~|o%vTrc-VQ3MlwMlE2)Hq#p%T$}tCF%*^^$58-|Nwk zOq3Q+n+!A+a!V2xyDsirzMnrV4EmpYdV()xVBg(GXfElff$9g6>dP_ev%$QzLHSF6 zGQmkx5gV3!^f*T8nUoRUYFFGeN85_N9;KYW68@(6Gz{y3n=5G6dPH%%>zqxY>~jz^6Bqt@ZcZb z{(=Cdx$HBE6i&RHG zP&kgZulVNVjEt4Np1Olzn=Wp8f|$Q0$$*=_V_9C4HDE3kaR)sMr-M%X|kEA}!s zb6wAn=PG%bhw20T&aY5w;w&N?&*;Q>m}|K8^Odu|ZR%V7Vx3HAa2=n(1RuxOfvWYY zRYa8dzp;0Z&z%7Ay5M6wnb?}xw(Vr%i8--t+jb_lZQHhOJ3Hsx^JcfUPVL@vU;bWn zRsRKD{jGkUPq*|V#GV(ssvz#sId24&W6?_OPeJ<^`(g0V*|Q;CU-x>X-~M8M3C>w) ze9?3kxgEnp4T~j8fzd&1Vf4|i0={9C-Q`^Ek*4r@Q|Ow6%x=F8QMSo~Rq$B@y5z$+ zjiferaKRQW5SlVCR9#(-fgbh@tZWK%3@YWmJz5%Z9157C>AU~*=>8rs@Gj;C`{{_g z)P*$F<>VBy)`xJ6f|ZT*P50Y?d5^tMbu~S$nTVaG>?%YdvC@5DK|yN ze;kLVa$XUvzJ4qrHexl0-z71wWxg@0=_(6iK;uJlVf|Ev^~1#zn4^3wt*ms>Mvc}UnuqKbm0w&NJ8qO+-Dtf(d9vl z<&myz!1Mez+IG9j9e2um$uaf*3-mr8Q=pg;H>xWQ3fQ1Sx494b($C`{fw_Yc1onk zYe&-#T&G+IANZWC^t+HS|68nZeTq^MwQP2q>x+D{f?3kH+q82q+eJiPAV%J$ph7*g z_NqCKFP&&Lhd>`@-o_IN8UNwI(!plD{?d6~cU#xB*+unJNB6N3yJM=YPB~HOdsTd7 z&1i2BHAagBw6VkFniR)fTq{E6`$ zRiH|XVH)kJLf_lkovRj6<>PoVv@T4u7s!^JAI@9TKu&7#qZ=G zn@fpw_En<(-k)8o*HiB+ZJ?i4!UOA9uAZphF0j-F(2xF3(W1zOSx(no;MLZ+Md7+4 zD0s#hJ+mJF=8)j#&$xSd0}@dlgQb;_)1Pmk4>-EufAaa?~@2_+VAj?{}*q8^?&FsppG{`7a^rTkn{SYQR)lFD6nWNZc+v>tXofBQUl zUVDsBu6|~vaWXrY98ILvpFd`{BlHO(1wwXTZxfXu@98wn=<1s9{48@e(#hm7EmlwQ6YxA4V{tXL1(PKk+MAjyxG76$l*34V58GSbER*oz+~Y+o<*O zOHza)Y|uoJNM}8k4W-BCF6I?zJ$WF1kfC&=iP%caxb!1_`s>(aDb4n}$_$zB1hr&A z7{wpVXY5$`pzNuduKfqK2o|o=%fiCcz>7vk)dN=8`T4qkGL4r0-DtOg zlJLLOwcNyxRD8ylzb8m*OiiXyKBX)3-zS(^r?V-%Ub*|zkPqH=3_f<8woHtlKBL3A zOtX{r?$wezMBmnXGmMX8Tk@wLxZGq`M2NjJ^=}!m&e4P;Ee0@_t*aADlE?B=J#avWeVX*!3TI zVv1LpbGB)RM^IN7KvQ55QvH0vSVQx$m1#N?wF-u+NJ7N~jc|x%Qsh~;i{=G-eMd1_aGw*`9 z`9PB$L_(4xFF{I;MFlqh8GGJe0P0R>8bV4ei7Xn3kQ zMZ7>9KB8paNOXvi!a={VJq64Vjc^=DIQnfYad`4wEKIoSw{MdnTdu?p(I}pOLdiI0 zn~aEK8m}9=D&)=;!AtcC1FS8eKGsaIcG;bUG5=)EU70c?&C=+MA*eqiwZXnBD+ zpfFj9bIf(n*aig0K|70>;YWdZLkh%au-{?YDo}r7@u}5-{}6~n+E$b2dT+EtpO9Fa z;oiy)!5R+DqIKYkK?n`W62w$Elkn6v(cbK5hD|qh7krKF^0j|aJ_?;$c0kRvlVU=f zkAQvz`YNJ;Fsq<_K=n{b`sYx*Knsq}&{Uw1;}vpJOp2Q$ON}eE;S@en@Pd?JAE5c+a15aVdJL)Z|4Z zjcT4{MtKP^O@DW?_!-!S3S7kT`>XI1JkYhkUW1u-!ZEd@!tz|qTB$kp0@|R;9Fmn|C&h{YVfh3XJN?|gP@0CrAX{5{Pk3y0CVSv zV$G)BfDeTxlc!+YoedZbeTXn+@a1O`ggQ79&{r^LlsG43F9yR7*caXf;$;wu@*en_ za79lFmJn~>Rir zZ0IwQFL2rQ#QDoHCUUUR;$nA_@UXL~F#^fCiYU2C3Bg96h7IGI=E_&0iMhg+K}fl} zhO+m=a+cJX)lPt|QS5EHT9FFNNvde#-oYvT(+zUDZGu6W+313Yb{AvdfViMW?O1f~ zXL|)0Z5HANh3%!n4QE#@31L}GFVeIQ#5vf8$-}V?xoXS=R=aLlRG9`c0+4X$;?X1wi7bt9K`3ZuP)u!C3dxu>W}R_u`JjZ!Pg0>n zL-Xv;YYpqoYxNmNfgR=Gta$b**5ihX>Q2lSyUG2Z#AitMH4^!yqQUD~UYEggBX3-( zj$O$1;x!&dD5h*QC&W@fJuXHQ`f^1;g1$0=@A3y7)Du$~ga1iJScrAeNm^S|MOA`(IwBg8--B_k;fPFPU%BLy!cPkaw5=9vOzB263|3b*j5B9%o-W0DAm zGXp^{2Gx&yW03H|6eNZqA>m9~*FG3B#VKo=&)@kB!AEv&}KlBdn=N$65qdW9N9`m7$v}aJ+K5 zsZH9&DR~P|UKNU`RT_{uEa|jctsU#v4vqSKpZ+~f)0|Uftt4QhHAUCKw7+%J#>Cy? zc59#ie4cG{kEeUrG;=4=1baEU9wLcWWq_C?apMGkVbC}^DxJ<)SA`}gRrac>Bk2*T z-P@d;U{vrec}OJ^lJS8f!?JTLKqeYcq!g)H^v@Fik;(IIge`=RIbzJ>cak`e$EXk> zgF7w!kQ-7A4?lyv|nJ9gi$=Br3f2Qnm{a2Fh&q+&&{3-mBbKGg(Xr1 z%JHC4^L$Ab|McDD!&H8AT||y%t?EZQxKi*R zEK36U7-&<-gn&;I$agZVpjhD#5FTM)8-ZdFG6;uH6lVs^Zaw*21ALN~7)ZKQtR@Cb zbyDmg+56jlzYhxNoZ2 z8(M=3kVGL69ZrEVA;QQoSg6P1?rll!Go&ZF1Tg-g4JmIAk=sr!|35Ng7PtZS0TYzd zm#20o2I3BM8|CJ+hZ#IS--*oEl=#F2MS!K@$Hv>L?|E=?u3tLI%m+*2Ik0_To|TE< zD3J2(2d;12lij+6$bFrg)106t+|H~I2_hyp1#V`Y_&Qd|88Mbwwto{=E03Tg6~!Rf zYg#T1+eBdj3Cy?*da5G00R*)l!#&}($R6s)zWKo=KX zufLfuiGZVq1hl2=vFgC?c!Bs)k|NDG5k^GZ@u3@nJJwg>Ssrzl8IeC$^Bz%tN|^o) z4W0r=UpumO6n1OTj^hvzG zr}&=5T+cVYbfqRnugJ!9Jp9PIyRo_4{tm&I@cMRIJ)n2^x_cCOtLlg7&kH5w4hDyxpdUQABVD^VJ)1Bn>rg(~pA3nRkPJ;kU)(PMDrA%} zqCX!hK{tFm1|5IgC@|rd9$6p>DH*f3J5aU}ZUT-fkwwoR2`)J)eFJw64yIX>+5M=P z0K5v~pF(W@w0fwvnn2I3K-m35hDdU{U;oerD4NIuSm|BfPOlHK|3nuu{Sr#`l7}IBFR?6!%)(uG*A7-go$jvA$MVo(FIoq5>Jy_NH(PMhSYi3_m z-H1Y}*eEcm3H`CjH=)ltPIk#XE<25iXx_Q}(pAonV17g>7qzeQlHn53sBP5?vo<|o zenoALR??lksnZGfVocRsr*!7(M47 z+;|c=!mm#kG?T3!NvVTid<^*2Zecxw=LcDXEpkgg>o92#qs`IF_-vum=3D!#%m2X4GbQa90c&H2#x!cwLjYgAqJDO9{R zmI^o2NMX>UKfA`GRI60FNf|8!)zsWf!gw&&KwLaZ#CQmMNOT^#N*|Y9bC?Y*0EQet z)md*SsOJb`$Ox1q6)r)5-1W)~hY_>mU+;DrcaVW?JzY)Iz+msXEVuSch3&Z5I9S*u z{3<$c`KMNcQgR3-Y0?BY_np#_%&&Nrl+5nv8`6=jA#Ivt>lV)<^Rn}}DGW+Z4-*I zzPHsDj!ZP!n0x+4XyvP|g^CDi?Fr1Tiw-Hd5be=t3Flw?>uHW@uR}Q=O0Xs^9F)rq zm3;gSN{6q_ACl{xui(1om8KW;vBRD)lGoL(SqUjzE`lZ_y{OWe1nmpn8I>tHZF^Pq zW!FQ}wED)7(;*#Zg^=`P+gUgg3(XH}40S=V%{Gh0CC2kH1)tgQ+`y8$Y^h8=3 z2rUJ&w(u&wS;e>#Ep<2OT`nZ&-38D!^J$^IsEHq6%CM<fOESVwO~>6FnYzz0rXmEwD;JY1q6AFBj#EfvPuY{q6dziF7Kg zu0lVqVys`;S-eV{(fx?s*ft&U>xlOVuKB!g8O5@D&P-{X?M+kXdrMvW2ihgw{fcGN z*>8yh%gOs}$CPPMZ&rD(V^#jx>{bUw!L^h)E_jZI)w`KLvy@cZWLuAFQ!wiRL$r$5TC)W^QSR zh(l8S2lKT2#~gWTP5sdQ?~iAiGS3mcz}kl3GC$yCew8XW_4|yd+a=648;=nBYlNkj zt)j~OU{I+!2UBLFGJySw_0{uNhlj(W(Q!%|BfZOh zpjdLj3uTJP^$J;&+h_EnWUsqqOfp+$w-bf6`7}?H&waK9GT#+wl=@ZsQaOQ3VR<=eztr;A}D5E9^_Xnet9B@UMS z-#kCV!#ef_E79OGa1x>-N6?4FdZe&!bCE&5B~z}dWn@7u$X~d<2pN@?5L26s#t1FNkgsk?*w6XbbO6OXy1M)deUWt@;EnI)TIUTa->^d zVzr4%{+>_dW!~m=NuOlcb|z$OQL@&$5)JFDEE#KyNNg?+rUM#z^2fCQ(Ls4wizPyg>(FH>Fd=p zGzstQmnDTKby;Wi)n$hxZQ@rNrB1d`11`g0SyjV)!O>fj_AL&FQ>Ta9qU7_~RfB03 z9pqG&>~INNWYsy_8$>SxkJY{rtP?oUeV1x&JFlN}(;P7kH}V5JCHcitPB}x@%J{^t z!Bb6d^lwYi5NJ+3Vq0x+Mb3I*6K^J|c(=NS5X%ekg#&rb=FaQ{_3+-COIYGQ6(|8q zl|7<+^K93_W`}B^ZE3;redX}R~-zr>VsOg zGrI82{2NL0o^P=Ovd8P*vCBh?XbW~yWl+3vuXTR@@>D!m8`!1MS%!np%XAAYvB+v} zHmS$X+~;e$WqvzBdF{lerjx0VJNkG{f0ldyX38?=j5d4-zRt`Bb9>wJQp=G}_%Uk> zc)1H^I~8|Yy1zh^-KJdfm4^3jy~`T;79ED7g&h^iGETJmPVhqwS?*YB$PIjE=7QFx z`P9}|3Z|k3NX7PR)S$wxu=46A@z-gO%*4!m@2m&d<8vw^YMZFt1Yg;!yPlV28}$dw zFQ956j~*&&R^{l}$#YGc%g?X7S1QNkUkVtSC6#JfpVHN8@2K(ZK{8;5NpmA*o%z7e z_$l!G&dA#sU9asiH0F}bIhs<}V%%2li#CnYnsg@BEeJI ztUb#)--@puDo0mbXt#_9S*m+J&k~ns%+xXbLraq?qY}D9>+I!!sV^E>VR#qYtS(S@ zNq_jJ#q>m>Q*#9LAYMFYD8AF;48qS*e4;+#uz^~W)vOc^owP28MhYD~z;;adOniP) zpLcfB6m=a(pSy38&62)`40{k{(cUfItS;Nx)GedcF8}`Z8~>eyL2(cK`_VUw$r?QT z>D+=1vR|_~@1!^)rh8%+0|#Z$27jcrzJe{CCp^ zy^&lXla(OuEhZ`1F#i}4tzOv$yy)vfvu^2gnW5R57IDZgfK z4d=hM-^z`B#yM3I@G!VfF^}9k4c6_{Ec0YSLLPqxs`|Rh10T{3bC}CXwF|(Rn@qdX zlOEueD=tW4!NdBesu8xAZLPTsk!m_s$ws3yUCpJZ9}aQGC{_Z-h#z%BnppI>7B)e< ze2y$QWzp~(w>xJoIQfN z*B*Pm#=S%DFzs>u*7da!v^+1zOX(`kFww_5zMS>1xB78wp{s-}X%yPcezjs$U1{+* zNF4`foJNWme(Eip4-vL0ZnGoZY<|32@8K22%>-msDu&E+*DZ7LnTDt|dtNB95tJS0 zP{*}Wj@P2BIXC}xu(q)8DWdwdenF?-N>;LA#|@K{$b6Q%xscr_)sEEQ$s4r)Yg%J9 z#S=8gI*K~9wCSehiLupf`XI5U)Ml(%hLwnvDzH(rbfC-x4k~Ba=FD;B`{jPT5R%|> zWsuS8fva6YSczKDHF!H+)FBJ6Am(yg_ZZ7fzy0&M!Kkspiph3B*<%zO2BWF8{I|1f z(R0OV=Q-J@#ip1!zGhpMvd|G9qG$cR_v{jz^wF)O6@uWNlfUMDa-{MaaL5^k=3ye4 z0s_NWfiv5+9agMSbOlqm`ODJ2hklfp#lUUl7&U2sttv#L!yWef0zN^7#b100n4NYL z@w-yGl5&}~_HIYzj=suA>VmyR_$X&+2C3u9SxY*vgw-PF{h)9ci(89kNMTHDW^vb3 z@VB6!k;lJ+@D571MW?4=ubxzB&c6&=CWBd|+1h@U83bnL)q_vXP!1R{FsNI9XLf(Q zLtVP&HnV&Z?N!|#RTD<@m>cw9vgqMLCy4Hbl`@4gb7&&TLx`CtxYzHEb^Uscd!KVZ zWOqJTNY_g1JvB!ilOe9(X_><^Pww`beQMSbO6oNy-Fk~M`fBhbK`}guG!w=_6xhVA z95F#h7egP&amMw8fLPl-anzq2EUfnGF9FXlcTa2YE)X>Jf>-8_Z{|8&VKYAUd_h0> z&KDy+%^o}tAgMeIG&FtK$izn73zXeAHFq%5MbAjFNc}Zh8%^eY<+e7Ho`g9o_6IreB3KDs_d>wy_NQ9ZF4nb-i#%)fC8A-OP|VW2lv8LP)=oX+@O5X z(yhXAZ0#sZcsk*3A|pAKBFWecp&v_q@D`XfmboSYNE#@sPUAZ@;zoGEx{oIdQ9heP zHfUJaTTdX%kkZqLk)#$KqC#=xXJbyZ=l_bQ*PJ`kazp>=fC%++$sW&AnixY&e(&H7J@ za_zjH`Q@B>%`av?&YOl=mzOP;iY(zmyT@eu^R?}e7M6@FElj)bb?d_<4ELJtU+5!a zQeXsc44;oPAw}i4LafA6vQwY(Cpey&(Scm0KSU`n!=sbayc2A@|17ORER~vGG_wXw zeOAp!A_gkJK^HI5HwR^y;oJSWbfgON)I8Jf)?ViDpxMja_h@g3t_$r$>KNS4*~B{1|I>$R%}9 zZF~NaanW$<3BP=yx=h=874M=tm$m1dAu-B*#qrmsB?D{h8XPO717-Sl^5nMFu3W$T zamLQC!AbqNFYwo;hXy(~x_QK-x7CZ|(WRf(`urBJv-%H)d@*BBds#*E_V&k4`R%;J zGYf4w%5yHwjBZ|$KNZ{08W2n44dr_5KZdO`HRFpHxAbQ(h-^ZsIUh7#tRLTc&6iL* zuZ#HZ|D~xI(kmvvTf)=3+Vky^+E^{!8o}ywe(8t1NO3vuxoW1!Il4~iA)00_lul5~ zv0J9O_z%L1c{zIJBI8*L2%|#(7rB5Bk_yeoJqTg5U*DBYx^_FIkNk@zb$cuAI>a}W zn&hJvaeFb6*WSeB4ARi0anO+c%dX)+$OY!;DEDDhU0fmudN3l0nlxa`=(gcR=&M_r z6@sU%9enOjWAN^djJHM@gqt5?^7QJMZ|0Qwa`r>ckVz-6@Vf@y!fH90#z$4j@0p8x z_oau55mP^>@-ep75Hx;-XA=74bLxxNktv1YSS*s8Q-N#hl#dhOZY5dH7>BB-3n_$2kF z*5Cbtem9oqo5KE-)KzL*{p?z*8zV3O;EpuX^RGWcGRP8ov=3+IP5YqF9_EL}RKq$r z!3003J<0zp>f|shpKElD_O}eTCx^Nwx^~1;#LjyVT{q;@I|-6`)bftHXMapt36ZCP zdJlKV(Y1Y3d_!?-oNTfrbnd-ba|`K1=lA^yo79||K7@!0Ux@T>(F*rRHOK->bk8zz>djTQln# zcG5;&vN`l=**vfIrFD^y4Ces9yU^|M2akQ%NUwG>N>3Tq+Q=9iW|RTs`<9j*^u7Fc zh8vtHhD=e?sz*2?dqa*0x8*%USI%pVdqRV`(vxpHnW=Y9o;`pw{* z)jFI9^xcgu`gTowwC8WE_c=$drc@o&%$f7e)@_1Ow-@yxmEBmsH)HC{Y)XFHbX|-s zv3w%x_`UuqN~cASyixi7OJ?wXz{*75#UDOCg$IMxaUA&K#)z@7W6meJzTW~Pk09X z(RpUeH|oQUIx8E=!IWg$=kSl}N&D+&3RI7xU1v-Czxyb~UCOi-iI5dvl)RHuqNdxK zsxWQ!JkN#2INFUaR@38d>lWQxmzf!wi7NgXzKCP9@3mlzQX`^I3>ZoWa3wjyu zO%x<;9rB~6*41ihx!m5|noPEe@l807GLauRJSyjUW9#igZz;n#v~>S?p9~pT*z8ZN zJ5e8A+1$H#mtLhhm`@y0BU)EzGo$OdgR@nec84KHU8{C)Mt+gjeGA{5ri?5OSVbG_ zg^^V|a1c)(Ki;@4y4k0QMMLwXv`_kFK|Rqu(l|{!zaw@ofSsdPXx69?JLe;$a4(oR&5!lHHcU84t8u?ioMkt7kNyC6DeT31D*vQgjuPRoJNhZR zc{dZNKseJqyLewI{5r*9(Tobw* zb)+?K&48uVWv4=LxWfu^gC=kaI*YHl`pB-olADRzE6XGUhjva?qSB}O^R%mrEUv3n zUrr7!K*K3@-e6pOC2V%FcB&@sE)t2ab^E@*ze9zrXhNyDEO5A~tsy-5)mwj+c5J~s zXqC4alD{*7mU_v1MMuN+_0h9z^RL?n8FdA8SRkE{S4Y_cG|b^n&!$883o5Vkv8a>I zb}?2L&4)UAM=4I5;*qE4KZCF^x4qm|G5yTg>}>UoHi=CxjH>9kDlx@IUQ+RUuT9bE zx+X$wEyOA({V!rW##2|QyprqdMg@gi-TO1nJ8S-4&Vu)A+gp(Bn#0?}TJ;Te$M9Nq z_KW(Tu3yVb0`%8M4TO(%q|hXdiR{iok8J(zbeE||3R}R3rN*bfy#fq`3yC_Yu$VKCZFG*B*A( z49Rv|nyT2-c0XI|L|246RNwqb%HlLoj73$v+nvrMt-F+o;WA%3H!6MmiITFSLm5sXU!k$ z{@yw`N?{IRDH}^OTMjr*VJYOB18*o*31}enRLK_IfFD?x)c!Xo+DOCy%!T=3lHqo^ z2{eX5*L>z1wj`nQd|6wke zgl79OLq+VsePk-S=rH`o_&v1p-E_q>@jf#MM~)L0Rh*VieAPjTkxuxpJ7i;Cip~?X zu5`#B?r*R4tQMELIYvB;LZ+&LqU)VR^>IU%q=PgGjnu6}31(~r->r#qSVdspbjWz< z*r$IE)#(Px^tI+%SC*CECw7P+SlTE}ag*u3qIh9-GByDeBFWB+GYS5*zP+yC6#x%u zZmhx)rtSUJOV-)xCRH+fp>XU{|GO@V=@&=h$Vcph@7okS{<(bCDra{D@!$++@eL<; zWogLW;%j2lU800!vj19{=JO41PR-jZNm!XGsNn75u-dA}+M9D&5>f?;GQUXXKXXC* z>8S1$A#*vQ6l~Z(S$wLzo&|CWoAIk(c^U&aBOeYs1;+=FL7gLvg4-PW)Oo zKKJSwhmW5nbnvv+ro%#-7YNJTd-2qTQUjHP@bhkoM}WP}!Qg z0oi}xxK_Cd`S*Rw#nV#SFZHTsAMFtUwm3sFOt(J)Cr>i*u1}mumH(^lMr~i55orU{j(>;`B>=o8x?+lO(rc zH4n{e#m8bt`_5;pRG#cAceIUiN$)zn4Nq#5=w_y?!oA(gc;55mc!>kcpppc-AoO9x z6OwA!;Rt@AiljEp6}l6p9Jfbn=hBW0ZATpR+7och#5XjdgW2DsN5Q3qF}{ z?!kmXz5GEP9_b8edl8FD*%r2ND0Z*%cxD|Wm~PW_xLiY3QyTZpTX zlOmGU_Pb^Jt~lA_oW_HVk#6L>oVXxl_B+H3;u%c8Z)Wz-?v0%246j_SAAyw?Ob%Ho znOT`4=R5;FGL6~k>#i-@U(C0P5$mwa%YJNumG6eA{z=^~56xxin=o%%aTki}L5oMa zRF&s;`>%dv%(S1%Wltj$FwtcAl#?$jhSCo1e4-=zyaeRdh9%On>p`40mHe&Mil|Wq zRaWXrx)I9F3vex&#O#&b%ipn{qkRI8*U`EXU2;{5Vwqd{;8;#_1O%Mp;U~W{9T&$Z zufi2iX0e!Q0-du}|BQs=bUfYeCTM9qSv+eQ9WPPRqJ{n_)zGoId7Zi3T>B4kpg@s)v@wtx{`PGKF{AIJqRdd;^Q=I$N?~u*fK)#4948zn;fEnhixr?D^+TxWNJW zg&1f!@208E59)5pE*2F2m!r+{MP?zN4HfU^-=7%lKN!6A9%6mO`&d6rAQ)bC8%sa@ zE^@YkKNgpn`#KPNu?8xMotGW)#W4;A|2K(CLs@c4Awud*lD{l_7WE1ZvhoKY53PkW3Vt<7s3A5U?-IIUD& zxBb=l1v7NN*ogWb$u6&Zws@AS&@At+d*SAM1TU9oE0(vnT;Z1*QJZhkY-&IupJ40a z5iNmAH|EKT>VtPYKt)%VCfeYXkt3DUWy0L?9mz5ug51p3{jhW%f)~+*tBaMDOJaje zk#w(q_c1D4ylti7eyXhOqya$(Jk>)d5OWkW_63;(JH{F$Krp1czi&i1`r7Ed3w>`q zm`@N~eCekA@fvuuIrlJc>wX{oU}*am_fK5V0sh+X`3AvB!{U%}U}GobPR~eq+$r7A zDf?cLCVuw05_~AA;mmCihD*TyoM#79=Q~+@6@*pys#|#}onBc8<#CDBA2aO1U9tZN z4I7Sq)c>s>`V+{`$Zr^2zc$cuDamtDxS+qNP`B&9t+kX7jj97NF9hWIKc}| zlkIIn_vyYnOh^si>*erG|0wBSEFgxH>GilXv8db|@x-mzEuSa3BBgsbpfmM(^}6+l z(!r5!n4WpAq~o&$&BLqncXOJz(LAeP=J~qt>yB)JljeMcyy|k(F@}5whN9ApDy`!N zcmi=&*Uuy3B;6o9B&N;0H4nj?OZZk%S@G!p)k`H}t$|;^!wK)6zd)V6-H4}#J;+j2 z%+qN~6ezYnDW=K7?By2uzU|V2$0>uRG7IO6$RdKPF^dQ+`eh^A<8gdreY$*w8K2!BF3BC^TuhefMM_&&?!s1Ue*XH2we< zJEkGcx&KvCu@#@)HB@&C#R>WjRndX(cv$&nniZVWnMOdOudE*wrcWP7(1+12(nOK1 z%THg~(300|dOnHB=mfh#KHN36IiL7;M$+1`@UDfJ>22W;bU|wGPMztEAZOz@@3LFy z(`?jx3nVAMUVG6U7u_>OweW+{{%h0OFKAtNl)ua1&rKx>_d_ur1a#W!6?gTO&8Mg2 zI)weyY>d3K_H3I^_txiuDtv!?db3U~(;N3iWf3k;I+%}|_sxdoouc#)5B;A)5(}Id z+k2_v2yPBhg%0Cp_skLfLUbZDm6V8eI!uVdpx)t^Ic!Dc(spJq)C`QX2?K!;v(RMj?2ycBAr~8QSUftWHn-hJOL0>KvU0TN3Iy3Y7S0HPs0_*lJ6$tyIYS&mY`0!x)|CwC) zZ;MU7rx7Dd%l{UD^Mn)tunPco0l+Q**aZN)0ALpY>;iyY0I&-Hb^*XH0N4cpy8vJp z0PF&QT>!8P0CoYuE&$jC0J{KS7Xa)6fL#Ev3jlTjz%BsT1pvDMU>5-F0)SlrunPco z0l+Q**aZN)0ALpY>;iyY0I&-Hb^*XH0N8~dJOH}@U>5-F0)SlrunPco0l+Q**oFTM zcH#e5*$F@|0O$n(y#SyW0Q3TYUI5Sw0D1vHF97HT0KEX97yggY3xfYeFDTg9JL(%) z8q@wW7+6@zn1s~Kt(8>%*G_?hUfIpT(b$Sk$ynde(cIaXPSV=Z*xp3n(Aa?v;4!?~ zeDFC7SCa`;J)4ERl9K|xRxRz|!w4qyOwMBZCw>LXkpnyifX4vv7yupvz+(V-3;>S- z;4uI^27t!^@E8Cd1HfYdcnkoK0pKwJJO+Tr0Pq+99s|H*0C)@lj{)E@06YeO#{lpc z03HLtV*q#z0FMFSF#tRUfX4vv7yupvz+(V-3;>S-;4uI^27t!^@E8Cd14cQ(V*q#z z0FMFSF#tRUfX4vv82&drhW~j33V<{KkOlzK06-c5NCNwh5)$}%jp|6B$m8y5!!GaGATcE5k8i#iYz5cW}ebO71Us()L`@Nu+5yBZ0ffC z{QS;;eSQDEo!vV1s&kxqp6QU~Q1x$Z^Xl9$32;F9-|Repa)UJrTnr<;o&SXW5J`*) z6_5q_O+|}2O_$`02@?=2P%Jtxc^e3Yk|bq_(l-j`j*=vhhmz^}0e#ybQP)*dv*Q>I zr)vszH?Wf{ShROx*BXGNDhfpcCddSIQ}4DN2}~rzA_Es?xOy3!JBnn5wnKp2>+8K* zDNslJEgOsq{B{9m|2fP((Vql#@V@5D0Ow!iOV|tLU-Su|Wt(z*?EeAOZl~`>&Y2X} zpp`yPkLBF%gMwTnZ#qLlD7PNVcITh75%UVPE|()0{a3VRJ-h)csqjIXFC-^}(`*7^ zbB35_22#Pi3=9nVBXK&VNA*&dx7zes3SaB|`NX(VNn`4k<8u>x*&wGBo?tjrYQ`?6 z@w>*d+%B(fkztzMti-fnuKM<#@yzlzAB+1hQ@K&NsYe6N*j9G?+05!@PSD;0dUbtN zb;nhSxnyO9=Wp|nm|OLGa<+$?*Mv*!sshmE zln8?UYd$}?UZ(AP1TY&WL#N{5AN9RZS0-j6D=#<%_Fo7ktSG@A{cjLv+SB?1aY*BmFNpX0jxMA89srB_$^gJ9QS8?Do0tEX+80R~n8^ip6Q7|9;Y zJ9J`86+jSA3gw;a7fWgi6-Pi2f;f=hACuT`cUNB=Nm%@|LxKN@JQ%}0ND23eTnx!x z+?)b^mlT8wCaD`e)8Vl#Y>nS;~`&INK9)~bho=w9gOjg#+|$SI~2 znHy4Bgpz3@`CZ`cjS!^k60mzZWSj%!VYg^0S2Y+tXx)yeCQkqP&^YX2egmFD=sb5I zaUNy?c$)ugst6rLpS=P{xGio2ny4#+W(YBU3CK=oE-rBbhUhS7D59tuM<{{lGp7WS zXg@BgKQT{ml!zi}IJ9^iW_Xc-j3Q|?F&;v^NE|PuVe#Q=fl?`?ZEtBG0Lb6K8 zCUV34$q~V@yKb3r*)XLe^$%e{4TT(%wj-kE0S>T)z#M^&sW{hgHAqhA8Z_tOi>;>v`p5qjD(@aHKmnMg3h`7RrS@&cfP$bH z5nAw>;Z5LO(3km#6tD_B7kCNs1O7}}Eau2Q)GNpt@Fe5{0WmN(uqY@tY$3>)Z=GHA z4ATh$IY{BSf@aVhLSlG6HC8Qk5C>Kwm2VTFGZ5?%Ap#17gDRLhDzqLesp7Z~L<9%T zbqx;Cul`HO1(Xn1d00Crf)Fdn2GA(^!Fyk0=3rDX6;S%{T}YIgTsBI9S^;!~0b^fJ zZ#|+LUlORZUVn|TkRucz72Fdb*fVqp72pCrKl}mUtY9f6utQQ{UGTX;I^kzRPjsfY zo;9-i%2F~DNP3TAOcz^*88SyAhkGz0=8I__xJ16)1SsM4nHI1IBwFh6-n&d&s-Kw< zUPF2_3Ydf8xLqiasDzv>DnV#9m@F!Sw~i99gY!gQXcqQ&r}jc#3}2WmM#mwXo)*5Z zghpR5Br{_X=xJ!;O@1Hqm@@VqT?A=py#=HRkDH}3OuXS}f+i>8LxX}_1+Gjazyd#a z*gg}VQ|h8w{)nJt$rXtee8wM%=#$Q17Tj$r3Vih`k86Gp;b2Nure>lz?=K-u;EWZ6fE>YrBaW8Z<75q#Gh+y#0cXK7 z$M`^!o94AsM3E8a!YcQ0L(a?tcRVE<7J#7qgUb>T!iE=h3@gFJ6*-QAODM0#);pVA zE|Z|lpCBW?9`Ony;WCem;XpxFHh4;-1ayp_wdA`zL7W5{*NQ8Vr(mw?U;nZ@o4oUzkQ4(o-FI7UKSh>hJqtB8NL>Ccu zJUeH&B>9jGGmpf|1(`DI+ZriOPk~!T`W|8`A_x*_2D*fS;$VBn_4!%+3@lXSN4AM0 z>xXq96j>ZVnyB1^5{fGOk1-_>q#8$t}`8eb!?JJTklq`GMK75;Qwp3|GA@S(>;Upy?s{qIi`Hrm zrz=*?!^mQ>FY$}xr{3|D|40sK#2vk0UbayzsD zyco{tJ_%?FfupA-lxQ{bdfo%51TeS=@}MKd@B1ST=lNg}G}JSdGE${^8;VZtW^Fet2;mQehT4v7JCgbg@0qCh%F zUHLU|Yyt~`JTI8!A{i%v5bGQ;=(JL}|g%MeKHRLLTO z)&!s!QiefPC7eK}iv+<0LJrXYY6h==m4fLlpgv|TC|K&La@&afTYY% z==hy)0InLg zO|RZ_{l)&y?sF`78y9>-P>#)?sT3;?PK1~|0rT*j^mJ39LPiht_0!0LxO#FVHFDKqQZ-%1*Ja(si5t!335Rh z1o&_SugdXb#jiW~_ZI|U9#MUXED^$w{V4vU3LHfs7UbuQ;7*{PhXeRn#}ItP`(J?^ zP*DO`Qs9oj=k8PjCe3KqpI8A`acKm>S;h0;CMj1?P9ep%rNWj#;sqa>K*Tr3ZHWP= zrVf`S0nHr!#ouCh48{s19NO`1%zsuyvFCZ9Y?&WD0+WymP~nct0vlxrrXY?*N>Bm- z;{>eW!ad|1BVG#P}9UOB4P%nFak5!!%>T_6u}P33KbRgn;-DJTK5#V3mb*5jR7x`K+|jyS0OIlP+me$w1PA|@`3bBk=^g@*{iubZI> z$%AKa9sgy2&EFjYN`-j(%_a#7DB3CBHo&e{00Fg&kAKS36UFZW=2oHU4JS1bUUeRa z%gJ}{vVnyOa$&Xq7|ikaVOq zR*2eevL%nN#zQI73-~PT&{uU1DKCiG0s9b*jvFU@^nej*AT_M5D%EniHP#KQ_)m0A z{k_N#15W{zrA4%Z^L=;HIwwFxQUmADcT$ibi5M)05rd^l5hhI#!w1R7_juw1ixr6? zR9=_^DCs})Ik0|anSzEo=?JTO=%l!0m3_H*5|nSsh4X=twFNx2Bs4PYLG*e?jz0ko zcmZPd3!ouQ=|9?=WUw%V7eYxM^!WOH57+JdPp$4xvjpUW`))f2);5t4u+xV1(eM75})8^9t{5IQ~v0%QTqgWcDS-${fnm22DK>APHvLg?J6(o!pty zbgj^#C^o1E?01AdC!^?0p7!4gf^%4`|70!UX z3YNL=eqb|V@UUM;$zzQ(w26Z&i%LmJ*;5rP{jIP$m7jtQpGLj8d>bO?GAp5nQJ0|2 z-urk7eXiJ4nZVQZmo21B2(Ia{*v*yrI3dfl3-8J=J5zP}xW?xBTvWZzzP?HIG~&%$ zJRv^Zv$wyFyPgGDsca>7-U^Psyr)L8mnMeMd5Pm0t^4Uz8-CBut*$(TNVo<0e~HQb z8(TQqY)=_ko=ew#G-Zus<#{uG)Yh9TlAve!*>B16)F@~BDbE+s+e(>=;y%wGg^^k zn*%DjzH*IVk>cMfN%@=RS{Ee8Qa^w4Ukul_;Poe?1|R=rxNr!LSx4E!O9yV`_9L{?>xbMS6nEj(I%Kz8 z&TNf;FsrOza-&tEwu#nTW3AY7b3`?EcTkHaE1ts#x870*sqtCTt+u9Evn;YZx8ze@3t~@u#<*nFLWgplM$ovdi6OFU0<(atvEetQN+l-H4eRa#k@KxKe zrN!(MdVTyD<7`I}o61^|*UeFPt2}aR?@aIOM6Eb~S{}f-)0H>pEvs-KjLjl4*IABr(m)Dsc)%o{{L!fgz_vClOb-fBWg)shS_I;3+FCDZm-8DCn z|JU`BTLxS70I0PAxD*<^v~rts?4i%3dVS*Do52Kepjt#$l_9+XI1JkDh)Gq=e@^8` zjp@l9J^R;vHTuCf60ll3sFNE*`i3Dz&KC=Xf53l^=|N?ZrYCbJ&i>F+d}vCoC!qsF zA-`#=$H>lX`TneZv>R|)IEBG1^;#_*B>j&10O%~u%&fafDNQkhlY~U3i6nndDuUq0 zO79u}!C|>Ebl@L~n=crCT31{u zjUneeY4PHZuk!Kf`-+O%YT|j#106cdph?7S?Cv=(luFS?-(~<_IZM*a0y0&yplR8W%*BLrY-d^3+YOBJt>3=cU zQu@VdRBx|u)^4=??Pof)1Y520+V;YlQ4pxXcrd?0i^>8M3_Qg0yxKh%GdebPFrbNe zjIbXYLCwIVD#EKC(i>YMUu(dR1&;y6DgU4V{|&a%5MqTVT+4`=Ni;h=|!Z^e1)5 z93%*K97Ny!kmGi*)GihBB@+yEKe>XwH6&*A=;4L3+FIg8{;TzA>#Ibtk)6ERopG4# z&fH<&d>w86)QNb?{rRefU^SLPwX!~s>0fKS!uMg-l&9}Y#Hmay8-V>KzvwdWalBw_V%l3x zK~^H}s<{vHP%KdW(hF4BUU5`zLbNc!qlu#7m4rRz&Vv{Y448WTUPTacgA!Hb!JF>K z(Fjrxa8^nf-S<=&FyPMEH$6X_G?D&U`5H7T=s;)7WY&4*FWX?nWTW?@GZNUj z002BK7NzGhz1VTzpnSXTRpK@NxiJp8E2m8c^{j&DiBq|Qr|rmdY%V?%)@B#OINcW1*XT!mp)`{!G?ae8&wOT=K zGac5o3Uy_%+V0GI@r|$x@8UyK&GIK!YhL-fU8WL!g5M0kD}^E~iGACP=&StT6|Jjk z&X+n8&=Sp8IJvEjm8lK{x=T0A%7GUew_VjXz*gv2vP;{Cjg+7jfVs<_R_ScI zh#7cdH+wQbs?=k&OvO{eA06)clq++jt)8*ok)QM22hK z?#Q?BMbW~(-E^jW(}~_DNAfcCPJQvK-YL3ES&S7n;vUJG_W7`P(HNr9<1^^fkKMA* z#C)BKwfqhF37ZMfhN5YWMDn_2B`HGW{0VZt<39xeQeSrUkk%OH&(x}Ok*etZ>uk^c z&Q3S1dcWv)QlIkZxVDwIjymF@P=@oLbP?7GZhHMHg&lWF5j{q2DPAWITQNL+ita@3 zv&A0isPq}KdY!Ja8_q2|_0jofRefI9yDE!xXMTMS$j|Hor(oXnYu)?R{kDvLAuUzC0JQSQ%VT&UHMl%KouSVds~p(EK=vI;H$3_;>3k zKV{w6&C{$=IKtJG=aM4SKAO!{ez$k4ZL3NJwD^8ZaaQaxXruams0$d?PfZE`SkZ~g zUx3-{)umX;%XDaPF*t8@LL;|oDz+a?eJz4yNLS+h+2en7$svJ^)xP5uAa3zD>+!$B z1Q_&;wAZlj3pl)zwLZ+~ftX_ecE8m`RFVNVOUa~Zt@5QtYMwKE@?!Ux`6YZG{G*q@ zwCd>RTGb?d#Gq#;UT>C5y(zuYmQ6hjaG%q|9}mhTZ#rD9?d77sSt6!_J|5DDuR-jB zi|$W5E?tEM#b3c~GF@d66C2(vFEf=>^kzn3;c;kCk2$n1f3Y9Zd#{?x-Up5bMc0}( z@oW5ttm}c_TxwojRzl|PdU+&vs_DP;>?sOWXT7g3H3UDy(x9UoEqZ1*h~@@`ZA{r} zh}PjBC^7xIC2~?_npX>9a(&YbetbgVlN<)Gej#T`k-=XuD-*k8elO*^!Mv`Bt*(_$}*$|HA#|!;aI% zfmR)rbW4nvIm zR0|v1s<&wV&h0%fwJfQ1HVe+nu%J=l;D&7_RXT3|B@Zvxshi@PR-Iwm8LVyFMd4E( zSnuXSpXZgQw3c=&c(S?=hvta~WtA@RzQGXDRdMBUnQ z)UG`Emd(rA_;6lw^{14HrCqRQmUcZRENt2q{~7%+Ak6KtsEy|f@37YKv<@haBlK$! zlf?iT3Q5%9R>g7{3x_^}9JqK{aVF#Ic=lN^Hu+8Ta0|K|jW=HE;F_kENjbuWqi~yQ z>amS}6R;{>4$UE*-{eM^bFZ#C|X^O0klSFAvYd!`WxmB>zhgMt*t%-bGcFOgaKlq*7Pc!bY`P z#5t*XWxZByb>jMp#Fd%#r90b3SbFyG*7~pKJurq7y-NBlp{(}FSe3pVdrftL9u>RS z-g}0*=@PJy1Qi=)pYIFr`gB9-%&hk#`!G$u``(018w|egOMk{Yxgn_WrgyTjt!_7J zd6ut_?ZfD9(YDywa%d?3>9b?w)^n@1`KYqqToiNX7-$-Jb8)_!MqAwA>>Z_l1LeQy z-j;T8()pHAaXIa}H1g5aBGWlttcB0ILh9ebx_u$5i%l}H)T+xh-27Dj>986|EI;E) zt#P?$fbMpA4D^VsxlS1{5-+!b_L~uXKU9Oe#-j@~KCwkRaDK@?gKTZ238BV-3qF(v2IyPV2Go{x;F&xW9 z`zVbgI7%g)8tZ9#>E#~1IQ^#9gk^O-&E)iL-IJqD`?Zdu?bof|Zl$ty5Kd28Y@Ey+ zU;kX+@$QvU$mWdEeu|*CTRZ=ncdI;g{prex8M0$^!M<*j)VvSAJ-Eq=-YsW^*LsyU z7|m_2jeULAj;o|T`@_X|K06-I8@zXyy&TRj%PK36(t$&9$?N!Yjpr)Jx>%$^^~oLH zSE9FeB_%(|`Pw?so*GqS{rPmHveqL0CQk6{t(~22ei2TK^j^+u^Qf2TqI|(PBh$AD zk3}@akH=}*P`CeKC%!Fngl~t-e6%;`RC>rTN$Srmys?( z)pyi&tw;_EA?eE&xT1V!;&R|jPYW}j-9+V8iN>DIy8mso21MI-x9!2aW}q{LA>#>mWqwDf8&)e~s!^bs=c6W`vV{q^IKlZptBqBl|csd?_orrctV*JlX9n+gM zR%T_}xIIrksIG%}dvE`%o<(HLa`)+SnP&s%WnMDJjxlEge-E~F@9Xb$ zwC_i|%QdQuesxU#9s|SkvVRd=6V*3yQVlThB2k|`eV^sYYVA_5M^W&52)J+DEc^^8 z`Ck?swdGltFKkrgF)UAZ^9_$}(xPy!ns=^jS`GzF9p(hrs-jtMgSJLkR&RQ1r)m zXYTRm{bSQgRQ!vdsb6&A9G||6JN0iB)Cd>6#eh!`FX<3Ps8=q3s5|$?h%blpQSr_h zvbs)RJi5qKO=IS_S2jRm?cWzoyOJQdles2r9lMNWWt+a;v9o#8;dHx8C1;g=-_Dm= z!NBL#HS62Mcx|;E1K-PuXQ|W&4@*{Q%tL*+9-pKmmUBn;sz#v-*L8x&2#X12q^sJn zZcXOATGrn5dk6Eddh^UP=ZBX@uDO$3b-r;OjUkQe0()kCzcDt!qZ4Aknq6|_ue&yXcya2m4%J|Cw|G5vD|(tq47 z?c(keVS$6&PcZH=oU~ob-_H&n+p^WqwJz;~O@O4JooEBn-B3aHX>Uz>X9oF+iSO~$pnlRVykfIK{_Nw{?toRjzYBljI-|&Cjpnskq;5XqV`8TJ z#hkX*xFiBz{V8OLNS#g>pN-eq?=eVF=R$5l9pSBz}>o<>&bw;K0-Ei{xD zco-{_(%(d;1>Z-jDf$@PffLkT1l*2m_ilrq$yF38nHL4lnP3c7mYEfH&1t5aSqqBV z>{7KZ>Ps+5&jnuDx0=EZ;Y*m>N{{vTTr2p-+_=9NlKJ)yx;K7vph%d~bb}|a&us3ZiJi-~?1lX8>tBbD=cyUAH#YILreWkY4!pF(hu*j9 zSJ(z|+BwX;vE9>tInb{Z?^N&O_TO|ps~}exHCl~o6mCTd8&oTc2s<~J4mNK7b&S{3 z&1)RMuI_yPxcT75R^lki{RXMSs~3m&O-RzSV}Dt&?O4^2kx2}|%09M4ltEyQ;(^3V zO9U7M$Mwjt3+j)?y2eC8!T1ZIHAPB*Urba^=@O7pK|VnfKdPy}TeZBx_s;F#AF?vD zB?E!1Ai#>AS+iBeyx4;`(nvNg8(l{do2e`}r;7gCsW3zjx!*>cajQJ&+#JtsXO&gT zB8H>RN=d27AJ300(kdOFvu8QV+4iD+M%(2{!_>W#&$@;;+xO=dDSS=&nvT`#jK*D~ zbIW5+@~dT+7R3ot?p20#v^d?2K-UGnOnSFwFO0dA#dOAeqi6OM>n*D>@Gfx*7=`jD zHd~*1n`@DU@@To=^vv`v89l|7E4OP;~;CYW1 zo1A+pRSrg*n`JK@^Yrdns62)Q!`^Nx?q5IrAMj)UtT?8l-7ouQlJ?*giZ&&wenH zgf97ZMbKQ#F-U*%dhPDr%iHVtd-xr3p{E5ab2>5d`emh$q5St(<#+2%9ekS|q|#$B z=Gb$uNItXAN`4V7^t3Lmr$<_K!Z$wD&2hni@te!<_jk67=4vEe)-}9Y4cWtm-3_O8^BNxB~|UM^Kp6P20}So*cNFThiBE$xz}BkE$*L z9>=knsVpf^YfevSi}}B!F_-KrcyjCzvl*4$Ix3;F=)BJsg`1o8H=uavv=YMUq~&}} zY#exD6G^H+d4mY)Xh}i=U@;80Yg5qZqgm<}K6DX=_Xd?0hlxkHFwD3zjB)2D&R~ui zd)sO{oL;X(j!$rz3wQjvp7Vui#nw7K+y|}Ook2UyRBij26&kx6nA*0SNjMf1Z#yZy zp%oWAn9Y#Mp(8P==J>U?qVSi}f&9_%eIU_H3H{zdt_z)afh=?xD zv@`@8JfyP=+I5Oar*4!~v=(Lt!QxW)L}SO_Vl0RtnN;bibzm&Fy6|TaBi#*dbAV`!KDaKz|6aFQ&zg!S z1sK});@#SiuP&_Z5hUS=N<|q1;OJN1Am~?r@4Om(;+@Q45OVRhO|o+%ns&8R3x%wG zdXEmZ4;$?A3U&ARz(%HqV#&FSXKArLzC1`;Zl-5#FW>lEdt=}r57#nhoRZ#s*8BDk zH8Mo}9!0sizZSU(8~23y=u%iWSa|1yKPCmQuK`DyWz2gSw3+7IH#4Wrn$|xBKc_{F z_Hc`h6K!s+V|*OW7dsy=5vPB+Wz}0Q{UWP2G+5NDUiQ_$dqQr)npk>gH|+0k_J>x) z#D|32p20SFeSIyRm$QQIq6eAp+-8xrxQ)jTL%*wsBWj{m54k5RscQI4={DLeWH001 zsoy5~sQei3bot#n#T<;~T({Ulxw?lM(@v|ERGo#IK8MCJ?#ANiV>7DgvTE&-Qgkxg zv)T1oGP{+mzIYUZYQS<&}tHQF5SPKyKvf=$a-ewS>$^h!0iuDulmj*0YM zx~APt)K=_I%cdO8?5*_9HD|yzx3xLLmhZx5<9hhM~VOJMWP8hb@6LIfRd~ zau>+R!F;aV#7c zZ3mw6;5!HNeLN}6q@;v1XM-I{u-)2cYus$wxzDjoK*DIm+%|1qqc&2@TLH|Dcw+B} zL!W5s+VL31u{o3h=O))mD?MY}hP#h?FnqjgUF1o}$s(_uXBhG`>o@Ar{C|BeK(_y8 zbh9j%?+&(^r)H&8H?K(LqD1W|cI?u15Hj<1%1zB?;F0)<)H=u8 zI&ZBfUD5MVmGq%CN3b7_a5mIVNbkI*Yw{?-5!<(C4-jyv6m&E~qi ztv2^(d{X=BR^6^GEDiOcez#YA+jV{7+ff;O_n#B~#)a6v|Mx^a?6Xq-0NLR019`8i zGY{dw51PvJ{weSX48P)9B3U`aD7HTAeYRE*2}R*c)77e)<@#?|X?Ekx$LB5RLKTRw~_<*W=}=$>)QStsYi!fC3U)4z1^tGi)XZLJlKTqzr(i?$dX zL%*Rt^huA657UEz2x?-+uU@#j$D6Y~BcZgu9#Ij0ZzB2{l5dUk0bO|Ymg>4Pf88U+ zrpp#}lQL~9BXuED2ovuY>6q=f$Ie>s_AYSL1vK}AG2@Z^)|^B}_ScH{+H&20?+wpW zEjK$&JbjwCe-kPV4i*j2(?alO?$o~_@?oe}zy$Hh^pB283QLr4ur&BPmdt9x<7>|& ztK?nO6e;HTpv>{>X6-_o5Pq3^p5gDsy)S_NW?gV*b!J>4Y`YYguQ~~4;8TVrci^ir z;+<6yeBbID%5*%_4#HpgN?v_;Z=AfeeS$itXSYI;<*@gu(QJmMZ~p9**p+rJ{X@?m zZ7CvBm2>ah`NzhMhDBAk^;wRiWw)q>S}(H2^0U4)5cbba8bN3bqihR*ljVK0*TZk? zB`-Ht72_JqHcUS`Ts6O}=fr@%Lbb+Pe+h77O}l1H-r!w_}rg{WyX=Fv*{xB$0=vSf-*C7PA69 zeQzv3v2BZP&0H9I;MFqbN_`M6ITWES2KQ^bz}6jL5o)toCCDB;wSmiZX8V~RrsJPi z?_8WXbDbCz1{l7;vK2vp<)1AW&8J_~ zUi&zd@$$obNiy1*Sm31`$l6g4^HBFZoYA5m+-PeDH7G-Dnj6?CJGh4D@Fv&0bgx3s zLEOKtzWnza?E=cS#+g>!Y*Bec6}`sZI;UvG;dSvb6qV10b-W6z@5w$(W)g9Z%+$V; z>REaL&o|m=7llig>u0mq&~1$5m=*=ohnEejrAWti1E4qldS;QF3qlQ=Tj;|4)@ zs)-ym&5w_$V3;>q6v0EUtl<%NHe5L>T5ri%65fphccpn1#4oK-`}dI!XERN`zO@PD%+Tp4SEPRP-&yC;FG}t&h=Mc- zC@K&z5G2r*pPZ1*wTn9iED#W^{Quud)c>T0|49x1lN$afHT+L%_@C79KdIq=Qp5kG zhW|+o|C1X2CpG*(Neyqq6s&#!NevqRNeyKGpVYwm|3ouD2q;grzRDF!*AbBh5ar@V zJ@0Y@2Z049fJO)aOA7P@g9-{D!9W8OML<(2iJ*E9)JAC3M-#ZIsGxTJUgrWe+EDKmy%3Pl+@W ze@E|(+3j@A5RaKR4gU0k68M+$wu=kSgE~~PhZ3ar8K3|j2YnPU4dnT3hD%Eu26klf z*66@$cljeDn2Z`TOd`tu78Mh`Q~qQi)Z@lxEQ5k)R#6u*Q%T>X`^@rJQJT*7co&I+ z79bQXnqfgAe^BZZ1X^$McXg)q#BKOf7E*CqcddYB-DIjRK*QucgYi&gp1Ek0K1>a_ zMMLy})0OotO@`m~xIbd2Q9HByIBMPy98qaYv>mp-jdSI8ucnEv*4fpyUH5jh8P!A| z?y6i&IkBe3Gez6l<94B!VIFv_E3-6yrq=Aj=b%2VE}ki;1 zC}I4f_Q|3B1Oz40)&6BDC$Uq=E-Bg3XC*DDvMq4q|^(VQUARu zas??d;s_}#{@1cs6A&#F+*ZvYP>DR-2P<59XA`(9d}fwP1w*uoQqoT;g&Ky26#4?4 z{BwgUaLgm{p|4;?z@f;1=Y%T4Vgd;c2`w~2!3#n$Y>gzur~ub~C4}xXo)?~wCMCG5 zfO(D!%Y}=G8cigKHz}Bih+r#{$bfJomIz7Jgpwj`5><50hY(qKPKzKbfP^J}JBmpN{)Lm zSrmppuQ+XoYFT(rh9E1p(2sejR|aZk=<2~Hj)-N=b?PMtRo|d?9@Q@j(*WP!rbk3T zAy0`f%I+ud<}V=cCm_sUpqQzufx*`d!3}c5h#HwcJc}m|yi>64u}Mu6N`Lb=?G;3e z;j{@+W%?zAB57zvILTPa#o^{0_J~M(+mR17DtjheqTSht0>eEOp$1eUjQ)m@%UFB~ zPsqt<)fZvnN%M`G%U-<38$S1C+sU=y)p0p)$ar)CQZ57m>X39aF#ujK86oo^mSG$? zFwo`!(p9(uL8|NsDIO_Ie03C(5B`_=C4E_+6Uis(H-fClg-;LpIT|OU5LyB9Ju+xS z8a2iT>K?=obX@_9hZ;nWDJ7nDq@{gK-O$AsiW7 zEkn61Kre*3>&51QBchmrnE_~{kk2_#`!Yd6Kr2CPz*f+@;LG4% z@Z~Ti2u_~@OF(d8Hh)NkX9Grs2Lc)k9CYCCx#t*KC~gEUKvE7FAXCMDz?k~RHNaA+ zg1wM_gTQFV0uv)40FprK5|A+{!`eIjV!%`(Rbb1o?vM)j+mr%W93gdaH^9wMzG)*< zL6$rb%D^hPbx}y*M-VV2lz*bYSoiyzm=fq=t7FBlP=Hj>mqWl_B7vw7Tn2*tkRVjx z&V#^u#jq8C$3sI|1Uf1Dr2@PWyuc2c5_TZ~Y^hgGyo}sn9fcDX=OKZ5#c?O%yI9-j zD0mt;iG&fmgamz1uDsBQ;5}8vm>`$x!$$L6bdziQCrihMw0gZ0JeIpx^UTtMP)8k_DT>0~a)G ztP2zoQbbLb6)ME^T-lQ`gozb2#8N`Q$7qN%MNG<)3sB1xMD$M-$&;Wo{z^otsi2Qt zK^`~chJBFkhVv7YGGwW8a=)ZAsiRUx^$AfLeI*}@=M#Ml!OBHviW4^I$7nKf#Y8oR z;7XY+;GtsRG;G9{e37zoFeXe&mZ((DJQyP|5r4AcF^;^SP3Mh+mCjudF(04;yLBX7 zm{|WTz&|=k|6AM$Bw=Gf<()hh$C;KeOhQt2>^O3mHYo^zNKQ-=`FEd*&QKOl2rw@> z=fJjyttY`{!7~KR3+wSz5g?1>NA|0dHjcxZ0n=hb3wSC-D6>Q-CJch7#{R{FhALe| zdMLk@lR^9&cF!A@gsdcxM?ghQ`bXlvur&A>)QV^vNUDf7R3MjzDH&Zh6!;u4p4U$s zD>oL6(rDDY!bvJ@9O3R|847Ly|nuM5N^~juY19yahQanfMgK*LgQN6oFqXj} zL(_2bf=fFLcz1y5A?A%w1DE;kkq;L>|Lw~;Gs62vQ3 zph7VuW3^0(I)oPt4Y3a(tBj=x4srH)4Vyth8sZOqRv2Hy z=*R0B${>ZHPDBRlT;*44Vz zb*&)CdK?+vKMuN|(1M;=hA}i@-ogF0!0k{|QwsHs1bT?11|}lyJb!@0#7#>ARbp6T z1|}lP1s5M5nNS+62$uU%2(YAikj?g85rqOuR0Zj1lBD&-K*&L=1eu5$eNOxiD&n33 zU@cWA8V;2O(3n~yWIRbk@yY{6E(A16_+XXr#X!r+=!>Up!JLkmU^`%+#eir}c1%i; zTq7YF#U(fr{uICi|AE2?P8?)rwCZ+2;z=M2M5HkSxez&4LlnHshe+@BEIEsH%?mfX4&8aZF=Mmvm4GgI!@!QMdx`6#n81`EOQ?QBQi9~A z0QTb>rI}a*SX3fH_ESql{yYIGaUyKTUSv>aSJ;wo1aQK21Yx{lD9|<*w$wN;y+IGW zAbQ#?NuyGfaagWw5#eu~KO92)_Le1}z_vW6K?ID5@!*PrrJ#_DqXO7|EKJD*M#J?` zeEz-BciNRx%G$dd|AudX!v=L%qW(p=SgtZ@|jXA(YsU*Y_u7@_1 zQA*+u=0gVy8D_+K(k!oDU{)$Af!@zy0OR*G0qp?ayS!1+B>bU(oQyYsjxDece?)l9xKzyHAAS$63c@)5 zJYi9Rm>>nLgDycXXp<2C2l35n^hh!OFYLQa0x(h6oSqR79t3JxQkVemMo(DaDk_jHh*R9^DB>J1mreGo_hcx~ z4zpRtO0V z7e+?K9C{Pq(V`2)gVVCxEq*f|KyTegP6BZWC88}Bs5IaBZG2TX0|wbB`t>Hx$^Z6< z|I$FLwHnDzj685HDPTUUPl@om`uoH0F|hrnU;mMR`u)51I|$=D7CR!uFt)3%AVNRK zY%hXC98z<-zV#;!?LVv`YJeyR_!F67n7+aGgXdt}x(Z?<7@bset&;O`lmVg-?{vSh%25Lrof<|+ z%OY57VR`hmjh$xU-3Ww+uM|@Zs5~LgDkM7)BV}Y3l5BEt5fU*C4UV|su%9n*rU2!i z0aOSj2{o$7KN6;M)FSNaAO{iCld)iL#0yf!_A@LIS`84%u?ecDGUf6R11*})FGv^1 zpcT}SNV0k~8}LC7hkUpKN*gZlgXGzWSFo{SaROTT_L!ll|-A!JNF9nkODbtG1t*MeO93FeQloIOtBSntiSi&5963 zTvxhHn}rVy?H$IiN|UrwQ;nUrar_~l2V|9K!Y3-f^dn$4R#kDs+M)LlZ2?6ap_;qh z>UFibdpRmZZci|iO&Wm)vp7TRKblBG1T+n-RV6nlA1E3cIyjJqfFNXOpb}CUxGo^Q zi~VP|gxzWv7@mo04Bo9-2~G_vW#Cex5nT^TZ9Iva{^xl6WCxm=(VR9$1`YM~BQ3ge zs89mj)d%Pr;!DL_)%&<(q+vsHb#&CkEJ*Rtq7Ew&D{@rwfhEK`XPB4F7%Nx~3HMB>ZF=nReOqJ0e@ckdwU#Cd$oVSoafVbU{GBmwn6eJP}un2$R_7oe>Si;4X+N#wmfV% zE)joN&Gpt~)iVl69EZMId09`0OoxwOkHxk@M=_g=(?r^EchCP6iZ8WgepWH1?>egI z_r3~=yU1=`jGviX9!ylVqJ<*ER{yN|)F9IAYQ7WNHOv59&REs-?&w5e$P3 zEx!taUI;&9``x>rQ8J*^CLetxC>2r22wBr_3(~6ZYlXJ9JvE2il4W{!abhcx1!U!* zRrIildJil3yOeCR4J@@+7VY2oc;Lk5xl)$R^T9YEMgIDCp(8l-RYX(_%2H3m)P-Nd zDRTZIo6Y;7IysZl5pz~porcf0fuG8(r9Mx^+5diMJTZ!Xyf`KFz4+$ZCOjp-4`)Q70mHi%EF zH>_<{j_2xqAgB3&0cnX?8u|K9jmfgMH?Lv~l-H^Hk=kSxoNBrg#VPfGP04I}CYFbS z%yHxT{#Ym{Q-UDnCODcP)7I%((s|IwOZN^Pqk~RMDXzEaP*U7o+RD6V^I$KuYGa!w zsPCSv=2abQ#fZrMa)gph>hr7Gbk|eh>H_1Z zJ<}ME#8dF$>C$ZV$287Kb%H&_suf@^C~&UIb;{|3oCl39B=#eg;-Ih?zf_v1B?A^kRGX_C}fQw$e$)71dFmbO*CLRERFn1%#E& z&?{XGdHST3d;EIvWdE`uJSF3*%CL|+UN>Ah+}u$C7%+RpyjybyX2x(C687S{Lv(3O zE}UmYdTU7TM9BGxB@lNCBwS{Jy$4HQEW@tESmKCx4AGl$bw|8V4j-;DJ?R^60 z%gdylKNRmen;JFgtBrQOJWr+@Cyo2IZW*o{+pFPJDm9w}#=$+R)EIA;x&u`=64A<; zw<(EM<@Vt$V*0+;^7AP=%!gV?!#&lemoKH5p*8*Pdp+e1z%lk{ zN@|i~k4?e7I?dtR6Em1n{ag0G@-Zbd5v0iDRwI(aJ9|v2>RZ+52X^}8qK%z{pOVh^g*(DzYkt^AT%mRI&hIrhg0T+zYoDHgdiB{Z z(=N+;!1`{tN0Tu1&xv*+UaSeeVP}$E!FE1yuul4p)Ds|$1XDe)(!)ghn`*3^S$4AV zn6bB{HBEcb8c5f^VtU}FKMbt?%QPot>+Mc+F%hkrX{lkTCl}H-_06t2eU*I7j{}Q< zuRHmQT0I!Vu5vj{axOFT#JPHl6ZGFCsPBZ$OZS0qC&3eOS0n8PY#_ULbF48g1Zc@Ss*EmN%yqG#2#;i#|$re+M5joaBsKs~-56&K((?s&yR=gCD?? z^Y?Prpfh#{Rk+w__?TVPI60PF7N2Hf<*dv?cB=b2+A+mocP+an81jAByHs8GIIizo zWWYja&!i;e)v9{GZ5PQfY!E6;#xG%9Zh^Ob^5tlYtCgVmtZLvr+@dR1p#}%JrnOac zCC90RoNhB_=iAg>HIGbch93NcAvJtEgFAAPr*2vyPhC?rjOOWxlt3x7gb#EozLF0{Mc$~@lJm;&`S1E1Hwx5x z8mI)GnXQ+{aDnr_*i1U};UgalL_0p&x#B+g&Szx&6Cj2ui1PTHR$&W z&Km!G=sa2Wf{&iOOa7P z^AGhP2l;xfRQRoiHw*c&OYR-?9Yn3efZ=Xwr|1A=B`APj2Mhdjw~PAolm5D+o;bJQ zwdvHnGvHnr?i2cfm!-|8LuG$D+$s5!NTTPu>hgJGJP2}rD!3}RGU1gh?Wnu0jtXnF z8*q?I&CaZjPs~B+PlrX>miKqZ`C;LYU5JqiOb@ktR_(`Cy|2wQL-n4MNbXjLFs%r) zj-~5}-A5aXfy|XlHrGx6v_~rLMH`lk%@}kV0PW8&pn#VPiga%s5BU-&N%GZM1%g&J=z6<$B9Rk+M zUUvYg6<=e!UhRMf@w!@(dtbq@A!cX~Id`v;?Oo?@x9$FTFrDx6a&su2bD>yvRkmI| znM`A&Ca@IzjJkjKB2NHmNhPDY1|4dbZu@k2oqlbiEtY;7XhyA#J0X&d-L$#83pjMn ztE9_JA{A~9)}4MsHuzuOnzFxy;+SV>)GU-nj9anCy_l{S3t&x6{tONm0GUN_e})De z--2DK^W3$W?=)8##Y*l#V4fc2)GTCHr9ZuYr}{TNiyjaOeoKHSf3a1Cp_$a!)Yex- zv2b(f9B4SV1q!Y+1_<@WHH?o!3*RaiWb-OrO*ImC-nJJsbdQQiP=(aAQt`g(rFbl8 z^A)^|JqAV&Wua;RF}3Upn#B<>44LgGkC>3q?jcconQ_&dno<=y9K~~bq?LyAX&@*k z&hMXiz4&}0+Dv9FaM81=m}5c8s>SwMk)=_{W+Hao*yB%?x*UuRjNHJrt})AO{mhkK zNtl;KY5b#^!@apJa-(l$)u?xs9zC<$xWLj-akQUCHp7T8VOGJ+Lfg*0?CYt&_88E= zj76%^v*DSONMyzb?bH0c^YQ1j3L~_kv;nkOuf!6&d=EPlv!T=^M@K-0(t@p9)b%p{ z8dr!hsy3Juva{z|makF!(t0ZYPlc2TxjNTiiN^3XFecn)#%#P>X)uJg3nP>@xy4RG zOJTF8PQ=6XvXqGubF|Dw@cFV+iX4aHx8*oTbk3s%Hyp=$`kTm6Q-@iUR0(B zB`bSa%@imel1ydORO9z0dQ;C6O9j{ra9ImX<;#KchK z&0@IUi9YVSnFqExc2JS?lFfUn-Cnw1qN{|OXThrfCerdU;z|y+-DC1N6xaQsYk-z| z&OcziIe+`8CD<)@xAUVL+(I+U`c2g;d$*~hc2X>8c!LrLY!%|Xhq#m`kQ@i|rno{g~Hkqx37oRsVjKvJSI~Zf*!$_g^cZa0w(#->m)R&9-mLIH@odig`KFx?n*~)&WrO-UyenljLsEmM4NI) z8tR94Z&5prUdH3uJk=!SNj~Vu0a%b0!+k1|m!t@`Efl-jAJMR$zYVn38FIu@hao-a zpZY3quGf=1-LFYj>>KWBf!W+U{sF?Us8{^;3ukdU_pQMYy?i}~SanVYBtQ3*tUsI} zz?67W2>6l(qd#Nmz2)V_?dw;1A(bxe>02Pt0`GzGpU||n2A;TQR8 zpZ)sN+@v~`Q6t6>9HR1(U7GmbIkmD1Xrt5r`qfW%?;IX&Rau=b3FT-rt9wucVv8BT zgv>z4wWi~2@7v>h=Bu4tXp`0$3{x$*#>~v0-m7XY6Uh+QT%gv@scZL=tM;EpdYlP@ zP0e>O@CN_W8pJMP_Ojphd6HDI^qcW-^NA6VM2|fT%l>H%(roNsp>7Ie4sUopk^ikV zxL?@^Qv8afH?M8>zF(PbyihJQPTakkp?f*Q< z9VnT0@Cc30!bvru%Uj&{n%H0VZEW>d|BU{m=>s8!cPZ&Z-+?1d&po0PP$1w2{u0oY zQIV{`ZcI^XGB`x+k^GXsTyG~!nHqy@ zyN*pZAgsA8TWCBESm6$nnRtuqwn7vg2-UOz=i1R11bq=KPM|4*E^>7H^RT(u)ZuXu zXEh^U>Sk!JwFg=>b9hu3|EB8T$#(7dI2o;EhSCNT=&_7F!R26Bp59oa!(y)`7PfC4 zrd8xrb{}8zh+flh@l6bVNM%`SfKMc@T&SX2x#>1>9&pX0tF@mN?_7l}+m)_Mz4p%g zV786l7lbb;=ZCr+UD-5i?Fh2*Y3Y>@H8EOE-`iS%!{JR_tb~^$cU_y*Ch@c!HE6{W z{e%3H_RZ^T0jLWGdDhbcvaF+e^Dwbadj`;Z_Og%s+#s~K4T&A@qoo)%2(`!7b@oCN z5#%_J4f6U>W?V&}p{HAhKAb4lnti>mJ~!!8;)etWjepc6#?~T*!w9SmAhZe`7{lpg za{$2y7vB$zTluQ@Qd?DeRr|pN2G3Z*poREkM3^;Cteq7ib2}pmF_;~X=Oskv8HZ!r zas2T(ah=b+^~w0)(k>FTxW;dFq;-+UPi)urFWe$YqARa3x1>*RHj*~Bv7RePxA_Vr zE%Q}(FHerBFl47QdZcKPL)!N|F;%FfuZ z;vL_gDxXBV8|uDgZXv(&{MG!ZHjX+yZJr;iP+xH$O)~~p!QZ$`0-g>U zWNFY$`b)8Ht`Nr6J#8j+z7Q@qaA!(yqU zhokIkl9|$)IyUv^H+BlXoDj4^b)0Bhc(&29?Qy7jX@G6#EqcnX*x8k2=n1RD%JX^M zWwUTtll7WLL0>#As=P9RJG$Z&Z)?Fs82 z7%y5K_&%?%zI-F~nEefEh?c&oHdh_cWI=E@7eH8B4{+iawbIa-a*kd!2c%}@V)xW**quK%!knOa&q=M#g6doq(M{|vscp3vV(t>3vsaX1`? zPF3MxL%Y(9V>>VLnS5xMg91t+?=5G@VX0dfshf8`8Sj4Cm9A+zxYBfGsczBs_7F9<&HXMTrIQrqJ11%f&mebWSJe=0;8uUXDO~1(RYP+=I_zAE`(wgyz za;x$VS8K(4rkgGA`uQlCtY$QsSeAb{2h z(KAd70UPxFj>>h~>q`CvchtCl6&>~f;_XV2r2}MEi^-IL06XMdH)!sn9u;t&TV0I| zmJX^ZDn-n&I4(h5cPbNvGYX<_z{G+SK)G959WRgg;X&C@EejqN{5NUp+d1izpaDVP z*{#y~A{s8Uq^HgKwOV-5GkbxN50a~%Z2*+# z0*6%cTZrrr-Awt$wF!x*A zxRjn+NIf^;i*g4(=1ZG%R0KS^@@I{URQ&Bk8Wb(;t&__1+>S1b#gQnOX}KJ$WjF7a zxd~6T=Y8=n-Q0zrQwocTz**{*QmS|FTZ`ogDUYS6^T~!&LycK;RvEoLH1}PU?rw_k zBNf+eEWvN!7~^1zl_H5ubK@>YL>q@UZC``OEhCn96oc{npB!7U>{->K8HDMFsNam9 z`?dU`ArG@a^@als|7_uyFYq)Xz9`$T)t_zXRlJ+sx0c{#eYKb@`PiEivV(AT;m_X( zffR<{aX-==`L_OU&z|G=<7qLQ9?#wlE~ida>LyJFS`W8@^#dWZW4o_e?xlway$yJW zuI9p)yK}7PKsZPYXqG0EEw+oGU5lNc1-*RIgZIpC!cI^wQBQ}A$HkOnK0Rit*BtrD zhIk~E;?C`hMvl!C`JPCKZOx=sV(r71g6~mr*5(P(*aJ7pItCpsy;SYmS-xxOo=mU9 zf@h6Dqsd~mt!*!x;@GJD>AOR4V%%Y>tvPWHJ0~xoZ+*Lp*$JXrC+Z4xw~*9iGG5K= z_@Z}_GP~O#84RIK2EfY+`rB3At_Hp}lT)4P&5;1Gm-7(H5{ixp&hw+#&0SoKxo6WP z4ztLfi0oHR8u{OsqQ|T31ihmY>|F`;gc|sSET-4_sy-dG2FyI01k`A@PU-HRnds`- z9QDC?mJp7H4tbqT-Hw?Tv8DtdkY_@K|{x`4oXBxEccXhn2xbW1RIW3SPE zX)vKEGS6{p1?&^HQj~4H)mabA8hd3@MdJ?sp%BH8Y-^A9p_uWL4Xam?EQggoDA`f= zG4j8v37|qgU)B>_VeHf1tS~8{(x|9R+S%Q9PA@sV-%9k*YDjECO3+eBLS}2*2Xud- zRHx(F0i8e+4PgJSn6uL*RENqMUHz`v2sWI<2EL(qM-npgah zJF%?z5F5?czW%u)HqESf>wjMeUJ2@_Ybd_uHCd26SSL_iZ3z?1+M1<99eGC=&be|I z=gjF?3$r$;b!ERFg8v4%uL7iAeCBLD_T>DUnii^vGP{KYsG?+vS3#}yE)@o3k<7Iu+nNrx| zTpg~ZefKWrqvl&x{3R8VOJaAP)U#jC@iurQv!I-oTXoyuWp&-wWAhGmG-onO(x5Jx$)8CLbJy6Be4dRVq~QKRPxgQ0I%bRRf`6y7p3E4 zkLms~L;HmvH63*IcA&n8vx0uQKLD$z_3s}+wuGS|@&86ESnID`XQ5R`~qB0(~16+6nT}>hp=5!j53e^Oy1Ds%ytBHgo|tyQVhdVehaX z?ViA3;A4@ahB5aQl&+T^n?xzivwwcR{6Mzt;PoyRA>za&QOIYlHmi7s8E2e3`F+H2 z-Woia?Q*eO4OBoTB_ZNAYO%4Lt+ja=F01G5M;mPD&R>VjYQwd=&qhOyTk3T$r}nL< zD4KLfsdvVl@u%fv_t(WH0J6k+(*}q@u)Xv_OiAyDP z(}}@SBbN;2ELi-@r-{;D)!q1wT+|4FNExU@?9O2?YEjQel3MQg1v z>aNkL*SH^ODb~r}OEfK~;BDKl8N+!lT6XVhqLbWDcpZwm*;KzNnva-C2tO0Zj~VTU zZwD_61jNY zKU`$8$DOC@mQXT}=wuB}hvb}-Q4J}5i+jjT4!NC{&c5iUy_}V&z&>VtXVyDcD(`Mz zIJHKw&w8raz8W8g2foDLawYAEm5ZNZR(OMpjxcpXvw=YYQNJWpig*b zJV$yd_Bg%41kzt>G?c#hpQmmBzAqTj=(mw~(HP13i9OQ1@`By_);m^dWbR#7E9ufE z(Z!3`hM$r5XhFK&HwZ`!tuNdAb^Qmi_c4*^_QJDC_L-e0sHyA`rR%PqBL zVfm3>4i{mr2gRBrpG5xx?1!|K(1gYq^=T~4XNP08dFR0B zoAYRX%4vbo{H-T&mOp{7pqV9M z0jyEIBctO&C_=T=$WXfO9v{f>xz<*Hn@lNC{xL(aW_asaKJYU;udhuDe8lKB#Z1B;)fs zc=JO;3Fe$$Q3f+ceb#H9-jU&>@PG7q)RV{nAdLlvKn?2IeRcv1VA!6ezqN^7F!eO3 z9gi4Yr~GZzD@6ddIW(C*HuGA!mURr7uRyiYu> zLY-*(SV?^$FPX9iuVX;jjo0HQ zv#>phug^!xfW26)bmtq+pfsEszw`2yuNl1F&W;rD3`~I1SG2J$4l(TTXfLjx!S$AHc6_oV-2xEUb0EY0O{7 zqMk?}7<)%uKa;7Pev2z zb=1>;*QCBe4XBx8#>oJ< z{L_3;XLv!)-1^p^-P?C%H0pT#8XH;Ze(;Qm>Kbxz=hJd?+A2O=%08|`W#pPmb{4iD z7oh^N(=9BbmsUwV%g#lfyR)r`6x$9aNY_`!oeUipI8$$3doi}1)$%M?Gcre`S~jz2 zZK|K&m)b|eKd_;I9l|x<)hYy24rrvN`qYY&=DGa&K2=g7ZpllneI^N2?lOVfP z?V`IC;y*E7E@X^mBnv_cVY;+^ zyfIGi=z71wd%|)SE-JAmr`JZSC83qA;b|s`zBj-9SIOmE6~dqwCc|-A-T1N_W@M+i ze%p6_b>hAC>^HvuU$tR{MBt#{pV|Pc{Qtck^*>-5V(@ClqvU3u>*wD|UA!@5oMa8X zKCI({h?j`_fW;{+OMboF(D1(EkQI`WBDHp>WT>IEuYO*Tp!pB=cuzH&_BJ3$e0e`D zo-VFZC;5IYvMNA+!uNU^m_kk+S{!rF(~UWLyR_01P7AeW5)`T5%n7AxN~!lvy#;`= z{Uc$69bj|yM@R)e$p=>d@^=1a67jslW7VKh&%6!FnML0}#gso}ovWPQ)6g-qX{V4H zDk!AC$ChZDa7!wuIOr>nD}>GrbLQU%o0wBY_SzUbII9hl&J&){ZRk0DAMY>w>b@Wo z$O9r67hwmNDJyWC-Z06cWBhmxn+(JfD4;plcnSSgLkV60a0j*pZ0Uo)7ALqBh$(#B zUIuyK`M|e(JAD`)tn7)~EmM>R1<)meVJf3oi#wVOGvfwNj0h?M^tzLqg)Y&!dDE$@ zIxtHe+f{8ig!Vjypx3sl{x>gwISWZAPZpZ5IHM5`b^I?xHzQS)P_&p{BuKMAdboPP zHO=R{My9D44Lp)O78#Ms!L`JEOP^f&^*}U(>3;^x$pi|x)JlFb#@@#s-KOX138S+> zEdVo6NRbu?W<4upJ7bMbfGKPVryNv*m#eg7Ra22j@Kl_CK24CC!X}*%uJR9FgzzmU zPWP8q9R)6saFLTA;l!R_#DIKt* z1gl3U!V#NyrjQ(x9#>J10wQwCddQJzjoL5+b|i+M$(Z-9(vQVDa_t8?tIC`!r2%9_ zq3G29w?iR)ETNFO+HaR5)tIR4s|YA?qEi)vV*7;4eJ%WIzdNoMZyr8w3m%%jB?+jl zK7!OkOai?(#tNIdU(E-xTSUrHRNK2>a1Ph04qzFz(FChF4kO|-(UpF+pF`Z=KwO6 zi`-N98boQX-oUX|WpN2!uj9EQ1=|R%J2&T&AXI9z!Jeg?T!U7h~ zBqSH5_Q-_^>7zB&uW<(yABBV$1El^Dd^OOp_#(rAATip2L*ASy;Q)1vRc!p!qQUji z(iws3Y24gA?(R#?dU7CQKjFT2cXx}Cp`mK0F;hGc&T91Me7{g6lW1Q*2D!_fnSmd0 zxMzZQK>#|G-)nB+L6YXQi8r_S(~h084^RacNO*yb7^Rt}B2c7unYf3M{5Muo3`V7C z{MV#)4{Q7zh*1>-!;j^2d#nciy$0nitdYaVR|^;UCYj<00#IuL${Nr47VDgy-bU-d zrv2LQX7oJbLGs5Hh(ctFz$^K#&x!G2o1}Bt6Ydre56sAJw8Y?M0K4MuEB)C~x=QR# z*xh0IsG?$kZr+eco*QB?7{!z+RnjMTHp+`UGAnSc?L6}L>8Dz4mZ^^jYaO(Mhdn)^ zbQr5m3^*Jg9oegs(_omj^V-a+s#7(=3}BvoOX~6I56l(Mt}OlxgBkfpDtjd!+q&T# z#6S8Cfrks3Yh_gfZTr6sZ9yF)HL!QxG!AF#`8)kg8DqhoM?4A*figIr@I^-G-=p7Y zf3+N@_<7p@j!I23S{cA*G#3-m%*t=Z%`8SF+Cj%L8;n{8ywd1{p;tZ;tkgsZN)G1) ztP{oJRtG^83zZt@A?D+SKaN->b|}#o)y46aHZ^V`kyGEapdsUEz{ZE@IyIWaahS*iNz1bpzgj338A{y$AWvkt(~QvkP8pLWz(x!@! zcg!bJ{fHFk3U3vcNGbL3?LjozwU*$D&|ZcMCFS-H7q%8_9lbTA3;aRx;xG2p- zookL|GB_P?>_J6T5{TU(kMu?wsRGj`LYk@d%CdVu61N=!^G*YCaT%qK3 zQy@bm%Z6}Mc`jNsYFO<)a1SRek+c9BTw(iL7g?WU7q~=^!e_H}X z8_=JU!ZS5=LAjuyvJ|Z^ji}O|ucaGzNLvf56TIv|Ywiw9xOU4w{n?9dVIATtZb&Vp zPb@{_V>@T*>!2;mycXT54Y>$-h|`?1d>dB~Txd)y3_T~KrH~^!FRhxZw2+u9uI^DB z%x^miwpcAf!h~ysuyL1W?#gfnw60s*5+;EQYfb^~teUv!99UtuxBbA=Zyk8vHxM3j z$hFrD@c-(@fkTjvqbZ?DzKHK>% zb%*W3A!I|nQmJcEZ!~NwEv6?rV=U1Xp9D+$=7KjJbvw+2b%oA@633@w%tb02_7`OK z)t5PjyRH*l9YL))N`*|WH&d;4kFDx_E2i35$7GIHQ%a6(qd*237gTJcFQM8SUKXVS zpImKmEo_7`A4_*2fYx3=tgi_G-K0#-X+JxAWG(BaIBt)Ext z!OYf{W!EP`|D6^1*ig82aa5;is%1P_2a*1*au^PtzMGH>*Wz7)LTvqV;DXbq-qJ8w z6tsXrA1zd#l~!zt7~LNGZ|WLB)htX?2NwbWTM$>`t!jqW7HhkKQ?^orEhlo zJ^K9iJ<#R6Tx5HtxLB-+d0ZoFNKnS1YsgHAu*6#Mrx)=W6T!F!*4#b<;MyVWg?tUf z_0^Wk4dnT!iI#qs^p-8bVfK<-K+ub#?XFd+1v>0AQww-Kd|@OH;u&GwK{w?+8TO;DNdYo%8E6n84AX&iA*00@kcNO_DiB{#nQf9 zL*cFO02Y?im6F?+`20%g+Yi&X4M}l7#-yb{2r}^RvU#J#b?4u8#(k%KR^q*D=9YM` z9lk7y4nJKtiw)M&u_W!0h#lkf-{qJ#k3<|sZ12O2@0YIFa;`Z&HsP-8m{GQSz0Nwq z6nQ%JQ*>m7G>_k#%-4$%gNi#L;(mn|NbIiB2yfhd8{Z@Ez%_A%*ff?GgBPUlH-fQm z7WT6x1?0L?J-fAqbRZKNjc?~R4ZM#q9uW?(kq%hl>x4^q|use95x!Z_1 zT~wzCK08TV4<*`*VS{p7fB3(CS;;{+A^v{=5o+@6 z|4SeOX|naT1U}=5l*bR5!ayj#;EA>y0u@;h0^T1aQJw}FP((yn0Yrg<5VdGsURl{X z&riL+Aj}X=L`38%b34ee{kZ$}*Y~yi)@yQl{X09IgUQMCWGcP!@;R#$c0d3=2)y@p zm!J&cK(}R1PtRhHtin?nnG=7lW+m+2Tn##`pfTKm+LSmFQL0E09fmX%U6klw4@a0Y z@a*hbF3KciQJj!aP|2OqI}3jdI54o|AlXOknAfk)asb@`A_0`&Z}O5JFo=DH-r*k* zVZ#Ozy*n=o_#cfR7=8N^J*UYPD%{$UbC`?3nh@)H$9IYkn|HG zOPYd~1^^20fkYoJBz55T$zq|~YutYQBOy#4K5VK$pt~8zir8oO5c>|WnKD!`Okcj$ zLTDpuQvQ`N`*Ui#l5T%nV~)UkhE%pBgctzgJ8>#>RPjM z(E)HH=fA`9#X-$Uln{L(lf>17+4z+&s&JFFV4r?`0&#-|Far`PImjD=F|r7a4jUD@ z1t=h3T<~|ES#$)eTql_=YYZnHN^lPx6GGxX1pfX0@r|FF^Gloqn~pDG;2IS0VsL8^ zJ`awZWrT3)Pw}HXX3T;QIZxn%ZIb5!dBxxCZS{xFf1z9LOKR!PwxeYk- z!82t3m=1OZlnk&DeN2`@&~ZLJ^1iz{M#LR=6QGEE+YRt z5iX+OycI5@$bWbULvqBypnP#`k%%-4@&x{PTsVpRv6xU}`J+K0M{=kUYN2?b2-N$3 zR7A={98`qruV0H1Yo0iYNHn*wu)-vIhqSPBI*$jcD)`pu_Ga_4a?0cCJ=zksrau>EJnBa&EUTl>s5qCoi&D~*E z_-spW(a*#_Z|4uiv*5XP7sOmAF*>Bh81Pq+p8_HflQQxbL?5L@KrZ$bbrm8h zPB91hw3r2gk!sRn@Pd|~r9lp0MXX0;$zRcOd`XEoT;)I# zfyjJ%Y)HhA4hG^pAEiD8kaJ>jU`p^M^bXiF=QEZ(Sa`@I=TK^Z=g^vfFXb^XZZRQV zzlMAc{iqaRUX820hdNdB{9q>M|`5dC<53P|r93Wys_rmtYqddUU#BA<&m>I^v?MbUR9d>Ldpe`kfNz!PAn^weCC_55>UWEE}yU}nnDKke^Ih34W$ z8obP?*%-2=K&YV@sp9+ch2H8@AfD{eEICwLf5IS1 z4dg8t#4qvLNNu!&T&P_7?I4WivyyeGV#Ws&X^D| zB9z>sXS_ur!Sf3NL@UZ{0B}N#J22}$&iC^(*e%5m3pxI??C004@u8W`uF|!R#MoI! zNh2_gIP1*$*L&`nRT+me1L3i7YS^9M@S!%`$+Os)Ax~*M>J1pi0i9)GY`71}{~cB-X*e@q z?j;R)5t}1A)JWo!i~((AeqRO2i@I~CJar>ENYHp1BcHL;oDxk1_PQER9LN&}3jWCg zd?*-pQcp@_2mud9z<_IrnRLFp6Eg$M9(Zde^~J2KbCzW^Mnf8uegc#VlMM&_Fc=Oz zvIoC|dHS+i^w{`i=}*TM`Xq^0OC`!i9M^B)aHhm^ED9bL6D5rF<;F?{7e&4zL8{`k z>x<_F*r)c@$2}9DZHIAY{_?Aq5zHlRN>+o%L4)Oq!UgVl$CCMNkP|3mX`e%9rr&6~ zyH|vd3A1%uD6K1&<1(_2#742>V_dHRf?Qe;Dw5PjYakvIkI*lo-@*d1McgCBC&GwI z2KoUakBRqVV3!a;5f>B{Rm80XdNJijNC*Oq54humAP_{Hz(+$JCm|{iNnBF!Ck8Dh zP5KNj<(>g%Bu*M0iLeTwB$k0sXB3ZsF$Y2|1vZHPpcnT+7a#;9BH~Ei)IJ(9LAS>^ zi-zbJ>Xb-`Kgl2*0wMt92lL~E03qf_7lr!NS9U)SaQ{~n2-JD`iBSn+fh>yqR{67w zf%0U54uk=&PVK}(?zVu>`fD#g>dWJ)lo4qjZ%)(nyCMFV; zSQi-SU^kSd;;e#dF>`%zDo`!t+21)l)TSNc75@rN-xQ0bR~r&Jt>|{zY@8a@kBs~O zo)?~{Yc8m=RO7MIn4#*TJKlR}qhs%Id2}v*zs`4fCeVIrntS4Dg1nvFju6GD(t|A! zd2oQf(QBNYl+R{vszQ=T`9noWgPEP} zF2M<~qK`d1*&gUc;3N905EPKc$bh(FudfaI>l45Xi5a0!J%r-(GI!v|_y%pamoK-Tj-{5g!4lvWAaDJRLTUx^@9npf)A+dNSt5>=lNh0wi6V&6me8 zHstuY3|s1L?<$_7jm*`oSN+NWRSdDju*Q>%g){?C4E#0)|0KZ(juZL<;ui9=<1Ymw z0dx9Bbfrh{)tAdN#3g!*1*c8JXrV_}C&mnxdAxs1j4Eoon{Qj<^SGwR@a1K|-2I+b zF=IpsW~bMPVPFW8%u{Dg9xs@e2ghsgu>!(4=tX(xUEOV?FMA;UMZ7o`J=pti_u+b` z1@w?(AHE$p7Df}FJvkKM0_5GFjBO0-0ch=yyqWD14rh$-V>A^W^c5X}!ISOaf7k~K zYFLf}7H~o2Fwmp9d~^u+4S3)Pzclj?#Jlf4CeVTc7ZN`+!ZSBSe&!~W zt&erT%aD{j{|utJFXp66K*ykb8&iRC0HygaY`^#yhfQ(e#|96V1p!T%y?I|EICL&@ z?5qZ{O^nbBLJaeqfEJ8)ZUG5O@?nto^gL?tu?H{?gmd9MK1}gwpjl~oXrv`sF_Ozi zPkxb0h+t#^oWc$#VJCTo?2+$0CtrCsEE^MQ^4G=^@!n-f$8@1Y(lIz;r#iAR79f*; z|38diL`EPv(tVAP8?-9&w%U}y%ggS!zf9KzfYBrT+ER@e4gWeP0DOqaQRW=5W5S-e zkWC?7o9lm=pY>K55Wd#)pApH#%?iUpW2KkHM9IY`yDrLw+Q&D$RsgJpBY^G0yA=`Q4 z50W`k6EdWjjGOjgyb-eerRatY7}Tqf?KAVMDcd(#q64>2%6#ilP%*5~L*SSR{;eq5 zqUPWSXCKR@1dzbv$=4aBJ;Bokx}pwUON*93TN2f!R0F@l%X`?0gg zgrJTpf|lCn>Gt^&Z9M$J=gRU|$Sq@n!3&z~3-c!!fiPgAM?X7*ZAHH~ct+H0zdAWb zqcG58S9(20JgTM6py{;~h=bsXVyIrS66SgLfA9dE*r3y+B4#$B%gU;j(`{}T5jQ!` zR<@FzlV6Fk__1-dJBxm@srRQt_xZQEbyagG0rNxnC;u zUL)h7YDIfzCy&XEyZf3fnbomvI7i#3O@hDm!heF>m?2;;Q#+R00LJhfsM2X=JBH&A zUWX}sPdD#0gnPBwL&NL?JR@W*mG<>hA~X7MdLum{yN0-UbFcW2*A9(3r64T=CJJIM z44(qjp}aCA7Z3~qq)+&Ge}8CS$2fpIJb6%j`?;gyUCNj^E2?@}EE=T)v%F4dxh9ExOSVJ>bm z9A_vd7ABM91c0~9kb@LL5aZe4EKKC1X-OS`1-Uy}SGDckd^E^YqNnUG-L-I(4Lbrr$#)cR*Eo*lwFL6jrS$d_7&q zoBBdA>O`a(MQwj!tSC%gZvek#w@FSZNU!%o#^vqmY!W!>sw=}&70tYkmu|AESXiV= zb^WULR(7`e3c=8-*kYIEW49No>_KULT1*1JtEhQTE4F+pS>u>bN^wF)!%9hI!9kZi zlQ95kD5%LY8;PZFF^x!OtoC$pNy51_KL~BV#h>qgQ5I5b?V#WUW_Yg$f>$M{=rHb50WDvxa!{oF29Zn%PbF$yjPN-@nwbAqLh$cNQ*q1`EJ z9K%zS%#G*dHX1`%Ux!TNax%LEvmv;5OL991g1nbeztOslVDWg%Jig)b$|(_Tuo2VH zZeBMU!f+QI(Yn0f!Xf*nLUOa`>d*kAH_I*tt7`r@v=H{iCvv5Ey}sMq8cJwLMUioI zQD3{7i*$(|o5uzZz#$p)enV&jy>_Q<63Z4cVyW8CeXV2gu%M-f^J0(rWXiT?TVH0) zcJL$}oG=9M!==o>sUh+)y&j|@I+GC1kHLF7ef-^en2vstYT-;1iaLAg;kjLt&oeV0 zh!u~?yX1)s>~OsYk?eS>F-kEdl7B~Dd}2DzY^Zp|7(8~PrTa`|6Z*~8(miP%vrDdh zZInr5llO~eO*=~a&Dpk&!bMo?BRx|D1srsRxA|%{?Y=!)jxocvfFAPq+9AmW)7T0) ztm?p50VNNF zbLgozs{{8JL>?3}iu|?+yP514k03j6-g?ZtIErnsV_(q z8q%~XTKob%g(xN>ya%^S>YE(F(dXxnA7m5uOBEF1ZIsFci5H6Wh~+3}@Te}kwHOwR z3>q%a-A`-9w2zR4;#1dAgD~VH416HIGYj&o{AdlPgp{$P8scD2k!NrBw$gRo1*g4- zaq;eFUnL9au4=mM8w=ztC_rHAyU$mV6t^n5+FWQ0eGj2m&nqx1hhOZ&IgLofEt9jS z49KJ8XBuKpXdX!KcI6ylsjct>y6GBR&U!${V9WQs^Bg%$Rn~NBmtwB@z#HQoX(@j; z-Ii9Azrw%0IoMPr7g01(osfiG@xJ*n2N--6{A$5r=|M5ocTRF~ejCwkSOH$91ZYmN&j{HTDdo zaYQ;3eLFTy$|}E#vmEo*yADU(qZZxzis5pgjuZOpdzd)~}^*Zo#{TQa#bnp{zns~UG@fcK(wt(<$C zIdnerP}b_(gVY+;*+FaH-nvbs4G*OnJW0RztcXZqB8i(l+C=X#>)PF3vJHV$c&Pxl z+*$MIiv#9K5l2yFz1W(XAJCv{?+H>XxvIXM*O+x9eL^Z{)! zly*5B)jgP)zrqbdEclg+O;6lgC$%$enoK3Ln~LHUoSBTBF}kYKJP0(OR|#8Mi30O8 z8G!q5EF`m@C+TDQlU3I!HR>px_X`;aVf?A5oXkoX3Wc-KS44d+im>RjzSd z!fOVdd8%vL72*=ckJQXhUR*8jt8Y@@zroYVE7nZAlP}f0!T!`3sPM!zZltH6IrGs4 zX#$3b%kxFNmaE1nMk`s43>~=xDFHi={trzN#r5;LW7ZPysWq|eTG42 zKXakvawI*yt`=Fet5??_XshLQF-%dI^1XsJp(HY{I3flTT;ZhrR%_hE4$mjoetL|d zMgI0(Qq;EyTn1kMZT>XY8^vZ|~gJe<9YUkBPDSdgaQ^3|V%s9w24G$p6$Fdk~= zSd`M>RUWC?Dj`Fr^?QZPcKy7QlBlK2H}?B&ovsu0(N6jIQJfhD)o>c|kIlok z_-@$nDZU`BUhwpjD!3o;c$i?jZS@FKu3C5p-@27j-^JrilA3*dFM3t0JcNF< z=3N2ckY~7XFSCGbCQuCDcWd22*83johvAi2qjd2pHD2s~Yv~Xm>1|0*^uV$hZkm!+ z^%PKIgxXN*$1oaV6HVX;H2;u{J*I0&FqtJ9Qx|B|+WNvy-Pl04HNV}@l51*kk=}#7 z()e*_Mqr5rG~{`3-Euz{I60~$MCT^WI?yK6Kbe+E%5!^UW2pLE)+`vpvp;24T5R(* zP>YDDpHYqi19}}QjEPngJ>QgUIoe-pbb5v5ZvJ>$E{e))**$gqg7Ia3`lwiJH9QZ| zx`A7J4M;5C3k$jmsZ0Jwb?wriH?*e=RWZ5_e0v# z3109SzzBxm{F=kMbGCZ-p|#kueEYsy1+JHr^a0g6`5gu3=*St9_S@j8hs%@xY$US1 zsZKV#Q~pL7aa9IUw-1ZSlAtt_tf;+3!%YHr7Fom|YIQlW>S-JyWz%s~+{ZxKUao;y4LT;g86zbtviV9XgSymc zE`6NOoL8tY(+B~pHMJF=F=VZbV??;1u*z)~58E<($4uwAtOka<+8o)`B8lS@a!9*v zAzTO2gm1nLBw5Q}lpKPh?VqbN?%bQy4SwL1=WcjgU=on}r4j-9ovy=#l~oJ)kP5lI zLEdxwT+4a)a;4;Gqm(>S(8}Z+KBo~eN{r-kNIrWo2d~aEWke~f7>~-8zLvLF(KjO= z>pU)NW68Qnty@;ueF_wnOLZdzR`C$;;qzJpvA9+%%7yC)v->KqS6HS$!Y###FkjCT z7x$Rs;!5FmWVjG}AtKH!{{R~gc4n7)x91^b7J4K#Lb60HyfM@SKGpKCPjLgbye@Iq z9x|mUx6(Uz{9hHX2bfx%&ZQD!uLLNrT3CV13~^HuY!YECu8~we`|dN}ljHD*#oRR0 zwbqiToQ@S7ONRQKSqu~U)fW|1|iVJ;*5cm7(leVas zR2d4i$JI}~6hjE2sr$WCBMOddwCb78XXdAaMlCs0vuGbNc^lK)EfMc}i7KfN_L~%r z+qxHl`(`%M#D`*z2U6k_Y2yHvPumH!I*%Sve&i^Nfs=&$!*?gKW=0e9!o=w}Gp+lXRFwfwi>m5-r!C!V7hL-<5;k+qX}N*c z32Nn|MpkCm@_(Wx$JiX@rMs?I4qoReBk0d5^_+<7 zX5+9IBv4MNeV-4f?wt~+iHPhDw0)NCzh?sJAWf`5t;R*T+a+ElDr_M54t^t3;1+GC zH#21yM0^NpiljdRkQrzKf)Da4lkL9x9`$(1%TK->PJ9P&C2|gYVVXPCtItp>TepkT zR}cD33DRh|z)9Jy+VaAf+|`(5s^9IAfX9s=xFfA zQN3fKapBo_N53j(tHf-0=nD;oX<^!3=z-IsG4?tmcCp;S;*rJ=Wx+!H2rgY{dmfg>`)qZ`|h_$7$t$xFnt zq(`=q4c)OQ`$vpZWanv1qyl#U1V~fLbv5eKLmVk(7A^d1E4oZ2r!E(yxF1&-%O*bJ zni;8pjgt7A)bW**{B@NuC=E0dZ(-)CHcn_d8AXLS-RJ>A8tq+~!hl1{+v=F3+YiS9 zCF$RJ0KEoiH6bj+ZkIK{;qe!Z{LWDW@`dk-9eAu`Yw>kujVGiPSn?Dvxu3PL*z^lC~ z63B6koH6(*POGL~zg^Vt&~|5D{5>5*iRMB(kFLgC&*ezmb`s^zy>*wua~UJ1(`~Do zRrm`}t91Z3=Xv&?Uvs5y6(pKV7FMerjN8AM?GI2RAsU_i&A-( z3-x-W-$L!gsFUD*x|@`k8y;vMkOj1V%yY&xuUrEK#Eelg+pI$db-v5kyLCye6P%|2 zFT2L=glyTcFSf!~xhEdqpjvr%p6Or9^PI1h*y@&@G_M{<`VU10bk243?JD{0IB)a6 zur-8gyktafV5|4gocI#uijH)wEy@Q{*moT)(!O+8{n6d+Q@B?pDLm?;=psT3=g|UrBDIut#L3(=5O}h82q{Lk2yp7!H8y7gPb=$%Jqb}Z zP~B?3<}<~p?7=8 zNS?K*>Se1j5yQDmm!uTrIv)MRxx2`)G+MuSba=bZL8*7Ukk=Yk?jPR@ zs5nTA5@y9LH4jLk-eb%TCD5y$KinGj_KDtU?TrJf-AF3M%2B1$mU(d8%Gj6G6B`t~imeG{B_mea6mLfl^87BY!qo1q5!sYYo4Liqg^8#yMFxDXy)>b6M=oC57J`Gvec~q>-lfr2 z?yuvC!crXUWDMXn1e+4qy3Q)tLrR3p1kE8MGA$;8Vh3qRu?v~lR zsUI{wbC{C#86+{meUMr2SBn5mpwF|9MXwuX21C>rDVk(gUOIb6-{oX$exfNBkVJdA zrR!^L?A*!x;L^5{|7P~oJYgQk|5RYi+UH6cYmnI1w;wrHFt_3Ub*2|d|udpfhcJc z21e!a4Ant_VE5F2nK9w4cU>wH?QXI|nqv%rqNEAemTow<7Ynd6c&C}C5HXEt$Q1jQ z-fgwCP(`=Y8!IWj@Yi-u95v~eo(dTrFNc;zABR5^u3tQ9Z*Nkk${A42EePnYX{ZW~ zzw$AjX6hTW3Y-?IMG|R_VPcr@nKICJyE^kKnE&d2OT|!x5)!~H=G|0qih{bn^lcs# zdWkLMvMK3ou$W8G!g#BN+muh#pt9lR1vN6x{@hsTrjoo3u-u-$W{Trh3Zc*0EQw99 zSC&9U)o>l?Fax?i zohdzJXzHFxPruZ%Zh1R7@tWmeql)~jf)eFbbu5pI*co?wBlBLOZ-MQ4{AWo&gAyg0 zJ>6Q$0c<%?1gY$T&$gTGZkvWkO{`3)vH+j>26pPp6H=iA``cWe5)na&A}?251EgIqN0|rAeZSwq`L#vqE zB)10y{WGUaGp1C_bu}eCNy~Tj6_Qu=lSZ=2rG4IrHj~zr7(*GklBLvOCcL^_3!Y4) zXlxf#*h)+-5qxRzz1K7;GZroZdak-y6H=_gdps;Q^K-W;=98u1?Ck2bFvxIog}A!& znxopArxr{Kf4iy)PVVlp@d{jV*?2H3bsTd+hef#@tgwjIu92f~jMS zEE4?8Z$6C(lk1r|EaNZgKFa2r+IceA75XJCD#$5UI3w0Mig)lP)b*$ zcIl&N*)iSr#iwZu^IYE6Z5yvZ+=9V|(+fXHhKFJYY*A<3E~%*Zwfkd7{AN)yh-}XVbbTw~ z=C2Zw=o3eOdq@>$@N5v}8N`6@3BU{k zqJyp1F2rD+F>L?Ct!n#j z{%}=*H8=P@(We;*slfC$udkmi%7-D{dC*vr_hZhHn_TFwa{=Ix{>W?y{yREWhqJu_ohPsDg3bb0caZ*)-Y@jRdX zZYRqacW%18w?z%OBx0m7b1mu0=S^{a;v7=@8hEC79_i~1)YZ#Y-Y;>#Z1u$%L0YLp zT*~o=f{=^llLuB{&ZlQ1GlQLNT3FEKn_XRU99lF= zJLRvE!t!+S3Oj3J)nkV)KQ(|y+ni+uOiKkBuZnKRn;Mty>gB#DP76fZtL3%Mve*kI z)=18$y1hAZyzKvSG1#96;_OtF!4*YW4?BOR5whMxnyoIY$GDH{Os6E^S>L>UoRZy- zM5<&+ImMAtsjdIcsSzq2=zhB=o|l_305SDne>O<9wUw)1;u*AG8LyI=6w)}#qJg5J z%h@dGS}w2(SEzsGZHg;JWv9g^&GRkOcwrBXqB2xfqbwIqaN71z@WPKx)@eH^=EI{I zYjM1SX5bFz#6e4C{+GU%rfRhX=!xjL#rz6t2=b*hc6U#6P{XD8Fui!^iFGyT>BO9K zs>+YbALi3>m6fE!2S{n#4VW3k^`{*mtt|JJi^^j9ij@`}OU z5A13I=j#bSxn@+3C}P?2>N_Cr_x#9tHQjhT$~6Rbof5LGnE6^+NQnidNwGh9Q0Nj^pZ;9~B4Fom##B z$U|7N$5@Dr8fcm)uQ(gXXJ0H*U#fx~kyT=+6=xWxRy&4XmrB7?44HiR=+)cy`s^Um zP^LwxL`5ofArpbXS&58{uRrvMekyppe{erk<;O4q2V;Osx`uU6C{fe-(Q=Hg_PNc4 zuG!`U9n*_ooP2Eq`@^g6d-F3x%6pBKst4(uTOs@3m>AuQb-QH~goXg|dFh371ndXt zvQ?cqW?^~WVgBuvf*z6FSYlEaG)ti-Yt*|^@S#HU7WOy{5V{slERoBN`NDAyG2c0L zpIZGpJRTfYAEVQczS3=6x8{hfSBBO3w|=`Bi;r%{Cpp@hFk1;aiYZ(s!KBi7>#vnZ znm(VGRHRCusc^_C$g>bvxz^>FUa|{ngSTd)X^-g1!V=ij!}6Lr7C|B%2-d%oRzJRn93Hav3e= z98C}5oTEX{Yq=q(6FWg9VKu~t1ZkgN**~X^JJCA6?N!WOwA1$3Qd4u*Mr3{j{l@${ zY9p%e9w`H@k1OysS(oAJsu_9jRkhDD$_bz|lk7w8p1a!ZRlwo=$mytq$4TU=sl#=& zZ%%^2qx(7EhsQ)o1iT6$ZXR-hhFzKk?g%X)|Iu5ukxSBTcBj)Pke?5aazqhx>ZK@caZ4BBn{|eYt*Zyb%ZcSwIvY z`_*Q1Y)+vM<`4H=_e{a~q6EmYe{Pet{+1`~J=A%-HYg=T{y&M=VV8T&3t6~Z)4*tNOs+L3 zXTKKMEzTh(N`B(2>2o+|d#oal<7rGICNsu|x44oh{nQ;4kqzp%JmCmy7h{%SET+S( zpvLKKt{+W0iFVij5lw znjJw&M6%}cSY($#cY3ey{R_g^T%N-Y-dfo&t8bI9VnhoCrdL*&M>h#s`Mzt+jo7yOGJmIo#LR%}UCI2g8ju zeIQ_baknc+D>Q~XX49eHLy-QzPAGotsU3GVy7rAgHOd1**E{K4#6w+20`LyiUmTVbQVo!fx{p^+<;(3 z3llv6`FnNjb~~$rs-kd*L#qCWk8y-FPNvbf^rNpybE*{v0_h3Du>@SvCOMZYoO^&QAlzdQg$|NgHKXo@*XiNurCi zJ8MB+*RnrGVG2H3-GAFuA+-IF7+E$5uQJojW8@pVd; z72hs235M!d)S|yC%2uOXz3jjo{t$t}W5irRHHgIWHL16$Cz!B1|6{LWpG3T1 zwk*OeG=PFgbUhabUwxrQE@zN_akxFw43jMTdhgwbcWdY6aJo2w+*IH6---1KJR?BK zu<21zpwUR=BgDr?@XCDG_pNbQx+DjOHo=%M`7w+Lf#u20R`>8(f+o{aOVu-JgmvO# zdniCk&4K9jX+z*4`>5$=|5xScD6)#xyOn@B>aq8 z82AO>%^6$abvJZSbd@<=>lDx@^bKu@z4@DVHCCcExzDRfJ+V{=)6}paW4%YNa6ZJ_ zut%Y(zEW|5Wc}G{F|mgnPWC_>u<2A8{iaG2Tw? zb-Fgm`YJm38S-Q=W^eY#dTok#Egb;}A`H`buW}NWFP)*Z=GQ~4UrGB*CI}Wm?k^=? z#CEC6eepq6j*goXt^(Bizfc|~!%@NGrqhH|R1ka}8VZk0T#p#sX-1)jVg%5#f2ZXY ze$d!s_9Qs4_tkg*prF@>lj+D$+hY!w?(YY;?(TN{Xh2Ah=W+D{A-;Z})?IIjeeO>R zXzneop8pUFjfK;2lY-)XaI9^oipV!c$aZ|L|QGWO0nPru!aa-{|({2jZ2_IoelFafepUpd~{ zXHnQJD@obY67xqYVdn)7t9&CdYz^=`e+gny@BpzOhJAm9WyV$+$>)Nr4J`s<_VH7vYFe4Tb#uTdWy3x zB-kFEyn{6SoQh{^;tP@}f55Qse)s8(oDt%7&l!>mfBY5d#%FC!{*hz!YK$!}J(OcR zlutR#aw5i$Duc=ko|()S(B`P`(oK=NpBhm~Fp}s{!N(!b%b*jMMrcfs^lFOC zlj=nxWo{rag1HxZ5#e0u;RgIgjUXh+c#Qq%9MdK$IzQ}WZAB*mSo(6G0$E%DC-NsX z0`M0#g23oo?ym3czo-%FT+;E=q*+MIvgngEmh9?+WQj&8tvC1|$Al}-60%6p(^O2j z&Gtqu$AD9Z{L6a{@?faCly={*zE zzEdawS=6Y_|1scSwZ_4wh%Y1iOojD%xaPG))hj-rEz^kmi}0qVH6ZfLmOAZnO?M1H z$n614J@!H4M#tr=O3Kxo&UA;VP+qJ0P<=Gx%K$?y*!nm54Nsv&!BPJhH;cfB`n3)EH4kknPKlbIrpshJ)7gZ zdzaS__U19R5i=A|4&O~nn$b5B*o&DEpu0gh^3K%m-wH}0G2S%k;_Irtz2t4J8@$)p znV}MGpCKhPB_;B*hkZp@3u8v8`^k)u`wwP>z(N8hxm762`&>UfL1riJXE166&*Y=G zJeMCb#;PxMTqKVANU%dbzDz(hz^r5Q)hl^)$fmf=H~meX*7y2N%OFyE<57^BeHz*u z-x;_)VZ5zy1}l&&p=6dA)GAwJdO8ZF+bf{BCIlRqFL1Om(F5-ChcdRE+<8JCI!t_W z1)k7=i6>f~L0g=igJ#;EZekInKYL)-H{n>}Y15caPO5#$!&$H&^d{&lO8r3_;;504 z^eP5ToFT=iaPi0owVN`q$3uh7tCQrhl_-}d&MGsR*kZ+SI7;fSXG=LugJ~xVD!a2v z?$QZ|IRI;L7c}GQsog!!1ZFisZRl|v+f3>;o2H?fC>{za5V1J%@uORYQU8 zCZ)*2!12OxH||HHBKCTY%W6%>YAf+kmG8$`d~c!f_+f_{Q&n#W;k%ALpJw(y9~|5- z>&Kj99F!z*JX=9&7Ba4N^mfe&OsP>J>$WPYVZ*<^^g`M_UGUY5TFgCr z8=>`e#zGT)b%^zKJU^@Ex!q-)WIj zPvx7=v9wYm5b(8r4C6R};ZkWQu1+&pkSYvCGxXg~nge)gT&szp+334&h z_`~UHY6G4MCQD^eigmWqY2Gn<)`ekGKRen>41()12ynK6P!HeW#mllwfB*ax)FCoD z{u_0X&s}8u0qS+8NlaUB+OB7g-E?0TpY_M17^2pCKVDEWCA!|6Z%@iZ`{A5mKEA=3 z^l3SeXJqEOr2} zv6(U0n8noI3BcswWbXiQ0$agOaGIMMo3XR;n!pB6PA+x;uPL87z>Lq#oRy2u+>D)* z*#Tr{X6o?ooH=NO2#UDb*^;{eoIqCgKp_e?W>yMv0MOLl%nE2BMBxlJXX2$05f=Pu z{LSyS$zeJ`5WktJ5QQZe?7+{$;^6FL%WUst!D4300V3&roUV1Sby z=x-H%o%vnT4P^DZl&h;Nvn$6hV0KnkHWt{GoSLa6z|NS-3J3xl15E+{!2ewX^y@T; z85SlW%u927Cp%*>>|dB`{|qe*iTl3{D}}J2nJK@i6Tld3?r@-sP&O>6<=3bINn@zcfFq$z*b;ez~4rL>2Kok%Y)xk1b-#^ zzj96Z&+TRBIW(OU)>eM**s%7ZD-Me!%)X(zy8{5E&-^o+|4sAz?`Qlkyx)@df1F%D zYZvAd6Zof3u#A!bm>WCWg8!8hLKIE_TMz{-t9}Xov?WAg?BHN)W%?_{SX_W+e@S7c zf21!nO!Jov$kNII!~iQV1v$&#ngBY38~~>O#)!Qs7y$mSw9RZ`!2hLx|5g>&O8>X2 zhW}f|-#WX0qy29p`j?*d_n5N$$^lpcK6=aq_pdJ7t`hd^qepOXKX`GH!$EI96z*w zGHndQ{5b?E0l=KB|AF)8uc&{#rS@l3X};Idt4IckZ z)c@csM-pCLWJA-}PA0{`r$nSLe(7Ztmh zrWH_C{kKp5kr?W))%nLH`Lns!yZ@`XzbPGa+31TbSf;;$u~~8bsdQ$jkN!E?VuBUO z%-$9B#?l@L;9>heq|%>FxQhI5O#DqLE;?wrAh1$s{o>^MV=*V{Tw@t-rp|8JA-zncH^tmTj9aYi5g-5lnPJObiRF>Kf$ N81^ZC95!yi{XYuYw+#RQ literal 0 HcmV?d00001 diff --git a/packages/Rx-Interfaces.2.1.30214.0/Rx-Interfaces.2.1.30214.0.nuspec b/packages/Rx-Interfaces.2.1.30214.0/Rx-Interfaces.2.1.30214.0.nuspec new file mode 100644 index 000000000..5aded7704 --- /dev/null +++ b/packages/Rx-Interfaces.2.1.30214.0/Rx-Interfaces.2.1.30214.0.nuspec @@ -0,0 +1,21 @@ + + + + Rx-Interfaces + 2.1.30214.0 + Reactive Extensions - Interfaces Library + Microsoft Corporation + Microsoft Corporation + http://go.microsoft.com/fwlink/?LinkID=261272 + http://go.microsoft.com/fwlink/?LinkID=261273 + http://go.microsoft.com/fwlink/?LinkId=261274 + true + Reactive Extensions Interfaces Library containing essential interfaces. + Microsoft Corporation © 2012 + en-us + Rx Reactive Extensions Observable LINQ Events + + + + + \ No newline at end of file diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/Net40/System.Reactive.Interfaces.XML b/packages/Rx-Interfaces.2.1.30214.0/lib/Net40/System.Reactive.Interfaces.XML new file mode 100644 index 000000000..30ff445df --- /dev/null +++ b/packages/Rx-Interfaces.2.1.30214.0/lib/Net40/System.Reactive.Interfaces.XML @@ -0,0 +1,336 @@ + + + + System.Reactive.Interfaces + + + + + The System.Reactive namespace contains interfaces and classes used throughout the Reactive Extensions library. + + + + + The System.Reactive.Concurrency namespace contains interfaces and classes that provide the scheduler infrastructure used by Reactive Extensions to construct and + process event streams. Schedulers are used to parameterize the concurrency introduced by query operators, provide means to virtualize time, to process historical data, + and to write unit tests for functionality built using Reactive Extensions constructs. + + + + + The System.Reactive.Disposables namespace contains interfaces and classes that provide a compositional set of constructs used to deal with resource and subscription + management in Reactive Extensions. Those types are used extensively within the implementation of Reactive Extensions and are useful when writing custom query operators or + schedulers. + + + + + The System.Reactive.Linq namespace contains interfaces and classes that support expressing queries over observable sequences, using Language Integrated Query (LINQ). + Query operators are made available as extension methods for IObservable<T> and IQbservable<T> defined on the Observable and Qbservable classes, respectively. + + + + + The System.Reactive.Subjects namespace contains interfaces and classes to represent subjects, which are objects implementing both IObservable<T> and IObserver<T>. + Subjects are often used as sources of events, allowing one party to raise events and allowing another party to write queries over the event stream. Because of their ability to + have multiple registered observers, subjects are also used as a facility to provide multicast behavior for event streams in queries. + + + + + Scheduler with support for running periodic tasks. + This type of scheduler can be used to run timers more efficiently instead of using recursive scheduling. + + + + + Schedules a periodic piece of work. + + 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). + + + + Provider for IStopwatch objects. + + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Represents a work item that has been scheduled. + + Absolute time representation type. + + + + Invokes the work item. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Represents an object that schedules units of work. + + + + + Schedules an action to be executed. + + 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). + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + + + + Gets the scheduler's notion of current time. + + + + + Scheduler with support for starting long-running tasks. + This type of scheduler can be used to run loops more efficiently instead of using recursive scheduling. + + + + + Schedules a long-running piece of work. + + 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). + + Notes to implementers + The returned disposable object should not prevent the work from starting, but only set the cancellation flag passed to the specified action. + + + + + Abstraction for a stopwatch to compute time relative to a starting point. + + + + + Gets the time elapsed since the stopwatch object was obtained. + + + + + Disposable resource with dipsosal state tracking. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + + The type of the sender that raised the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Represents a data stream signaling its elements by means of an event. + + The type of the event data generated by the event. + + + + Event signaling the next element in the data stream. + + + + + Represents a data stream signaling its elements by means of an event. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Event signaling the next element in the data stream. + + + + + Provides a mechanism for receiving push-based notifications and returning a response. + + + The type of the elements received by the observer. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the result returned from the observer's notification handlers. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Notifies the observer of a new element in the sequence. + + The new element in the sequence. + Result returned upon observation of a new element. + + + + Notifies the observer that an exception has occurred. + + The exception that occurred. + Result returned upon observation of an error. + + + + Notifies the observer of the end of the sequence. + + Result returned upon observation of the sequence completion. + + + + Represents an observable sequence of elements that have a common key. + + + The type of the key shared by all elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the common key. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is known. + + + The type of the data in the data source. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is not specified. + + + + + Gets the type of the element(s) that are returned when the expression tree associated with this instance of IQbservable is executed. + + + + + Gets the expression tree that is associated with the instance of IQbservable. + + + + + Gets the query provider that is associated with this data source. + + + + + Defines methods to create and execute queries that are described by an IQbservable object. + + + + + Constructs an IQbservable>TResult< object that can evaluate the query represented by a specified expression tree. + + The type of the elements of the System.Reactive.Linq.IQbservable<T> that is returned. + Expression tree representing the query. + IQbservable object that can evaluate the given query expression. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + + The type of the elements in the sequence. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Represents an object that is both an observable sequence as well as an observer. + + The type of the elements processed by the subject. + + + + Represents an object that is both an observable sequence as well as an observer. + + + The type of the elements received by the subject. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements produced by the subject. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/Net40/System.Reactive.Interfaces.dll b/packages/Rx-Interfaces.2.1.30214.0/lib/Net40/System.Reactive.Interfaces.dll new file mode 100644 index 0000000000000000000000000000000000000000..48c7ff079e56adf18184be819df677c96105e94e GIT binary patch literal 24136 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 literal 0 HcmV?d00001 diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/Net45/System.Reactive.Interfaces.XML b/packages/Rx-Interfaces.2.1.30214.0/lib/Net45/System.Reactive.Interfaces.XML new file mode 100644 index 000000000..30ff445df --- /dev/null +++ b/packages/Rx-Interfaces.2.1.30214.0/lib/Net45/System.Reactive.Interfaces.XML @@ -0,0 +1,336 @@ + + + + System.Reactive.Interfaces + + + + + The System.Reactive namespace contains interfaces and classes used throughout the Reactive Extensions library. + + + + + The System.Reactive.Concurrency namespace contains interfaces and classes that provide the scheduler infrastructure used by Reactive Extensions to construct and + process event streams. Schedulers are used to parameterize the concurrency introduced by query operators, provide means to virtualize time, to process historical data, + and to write unit tests for functionality built using Reactive Extensions constructs. + + + + + The System.Reactive.Disposables namespace contains interfaces and classes that provide a compositional set of constructs used to deal with resource and subscription + management in Reactive Extensions. Those types are used extensively within the implementation of Reactive Extensions and are useful when writing custom query operators or + schedulers. + + + + + The System.Reactive.Linq namespace contains interfaces and classes that support expressing queries over observable sequences, using Language Integrated Query (LINQ). + Query operators are made available as extension methods for IObservable<T> and IQbservable<T> defined on the Observable and Qbservable classes, respectively. + + + + + The System.Reactive.Subjects namespace contains interfaces and classes to represent subjects, which are objects implementing both IObservable<T> and IObserver<T>. + Subjects are often used as sources of events, allowing one party to raise events and allowing another party to write queries over the event stream. Because of their ability to + have multiple registered observers, subjects are also used as a facility to provide multicast behavior for event streams in queries. + + + + + Scheduler with support for running periodic tasks. + This type of scheduler can be used to run timers more efficiently instead of using recursive scheduling. + + + + + Schedules a periodic piece of work. + + 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). + + + + Provider for IStopwatch objects. + + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Represents a work item that has been scheduled. + + Absolute time representation type. + + + + Invokes the work item. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Represents an object that schedules units of work. + + + + + Schedules an action to be executed. + + 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). + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + + + + Gets the scheduler's notion of current time. + + + + + Scheduler with support for starting long-running tasks. + This type of scheduler can be used to run loops more efficiently instead of using recursive scheduling. + + + + + Schedules a long-running piece of work. + + 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). + + Notes to implementers + The returned disposable object should not prevent the work from starting, but only set the cancellation flag passed to the specified action. + + + + + Abstraction for a stopwatch to compute time relative to a starting point. + + + + + Gets the time elapsed since the stopwatch object was obtained. + + + + + Disposable resource with dipsosal state tracking. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + + The type of the sender that raised the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Represents a data stream signaling its elements by means of an event. + + The type of the event data generated by the event. + + + + Event signaling the next element in the data stream. + + + + + Represents a data stream signaling its elements by means of an event. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Event signaling the next element in the data stream. + + + + + Provides a mechanism for receiving push-based notifications and returning a response. + + + The type of the elements received by the observer. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the result returned from the observer's notification handlers. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Notifies the observer of a new element in the sequence. + + The new element in the sequence. + Result returned upon observation of a new element. + + + + Notifies the observer that an exception has occurred. + + The exception that occurred. + Result returned upon observation of an error. + + + + Notifies the observer of the end of the sequence. + + Result returned upon observation of the sequence completion. + + + + Represents an observable sequence of elements that have a common key. + + + The type of the key shared by all elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the common key. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is known. + + + The type of the data in the data source. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is not specified. + + + + + Gets the type of the element(s) that are returned when the expression tree associated with this instance of IQbservable is executed. + + + + + Gets the expression tree that is associated with the instance of IQbservable. + + + + + Gets the query provider that is associated with this data source. + + + + + Defines methods to create and execute queries that are described by an IQbservable object. + + + + + Constructs an IQbservable>TResult< object that can evaluate the query represented by a specified expression tree. + + The type of the elements of the System.Reactive.Linq.IQbservable<T> that is returned. + Expression tree representing the query. + IQbservable object that can evaluate the given query expression. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + + The type of the elements in the sequence. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Represents an object that is both an observable sequence as well as an observer. + + The type of the elements processed by the subject. + + + + Represents an object that is both an observable sequence as well as an observer. + + + The type of the elements received by the subject. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements produced by the subject. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/Net45/System.Reactive.Interfaces.dll b/packages/Rx-Interfaces.2.1.30214.0/lib/Net45/System.Reactive.Interfaces.dll new file mode 100644 index 0000000000000000000000000000000000000000..808334b428e9b59a081031942195089e8345f027 GIT binary patch literal 24136 zcmeHv2Ut^0v+zkFH0e!x04Y+!2}O$1yYwPhPzVr;K!QoA7K(s^BBDqWl_Fw6nhixn z#R4cGR;(zZSP?}7|w2Ku4Ibd*5XQZ_2L~V~DtQ*s*pa5lH*dCjmeZztI^3`emAeWJUf@eaBHG3Os87U1ua<3SKrOF#ZrB$krHy zeIaNT_*iN~kQDg-?T0wobhHQuz-^}$Cb6h7EP&q>1^}d?eFg2F{t!X!BnFe=k3=GE zGX*aJytBbO?J)%@BnCB%4l*KbMcRz;0FnXkw8s>J%%`Dfuo~ejc#yVXK_y>^U_1mN zh!csN_P7usC}A4@M?td<8+aA%?7x3J@3crOW4K7yOh@}=tE%t?fm_>Jz1FPTp!3DO zbXIMw^h#FP;6{?2`id+9xtFk>q@&1rC#mW>(RS{>z1~*KLyo&UcCCD+H*_sCLj0?|r48AV_-xb_hj1XE76UkA{J2t)w zi`=0)5Jp5y!Df-2CHOW2JQ)XY^Dw#}k{LW;I50M1M>#nWLH(wvjf^)^yDWH-;Y7ZO zC~$!nbN~_pFEWJ43#v!s0ajeSo#XQ6ipid~&#v)-m6fQ$y016MI z@B#|EQ0Rz5a;`yP3JR+L=52eYEVv?A7C?FT$#TI=W_Hk7r;nW?%y|FbI7v zv4vvQ0hI}CJ=S$N$9E!0;;<_QA{>HIP+;em$j-};-8jv}PVmzgw_9^Tr?(H~dK_@hIF`ftTT@Z|f zFysJUE=Ux-Vt{XAAZ|8DnGM3TL0l}f2rGq2L}3~Vvrw3i!eSI2Kw%9EPXZ{1IR~H$ z)PlxzqVO(&N|=`bs$<>*r~-XOAtwq+kQ!8pB|)npKO70-hPp5$zK2e{0S z>exseVr)d>BmhS+pvPDsgE)u>$Sg0=D1tx-3!$b+85UV7Z(=tiV}{!Y;A~tKfD3R) zyaf)ipAMm69R529KfqzY4272s9)gUiSY7Du@GFjAck{gxc&kBj6lI&a|CjFH6XPjg~ zr};-R7*v{n>@R7SAWk4z&1*;!C%{?ss} zb&#D^6qUwup|AiSXueuAad&zo!=H*!M{`Y~&VEcPBZ|sE3fM5{krC8@u_%Nl66uO& z7^`6_j8K}wraA*SNduinvQHy}bZU$%2*rsYd6IRJG*(DBbsUA9QT{<5W`0b1SR@Pd zY-$W34|ggJVVeiq4>JZZ&paRxPfA!M74mSSG9$xSkcT}r7Gwych69E`b~75{G1m2o zSkQ4YMDl0R0Y%UR_Xr9NvW}$rgLY1g-sIqUxU(prH2^YLlj8^lQCU8gkyNBKWJiml zhf<*l)DmPz;++EnnN${<(}^BEMqhi9K7_=X0U@R%qc&0N^Z`ezunMC@FsT91#21OP zV~#NfL{AGMDdS8+3nEg1@@YJBig9SjmO={vA_~|*2?+3Ura2)S6$Uk&9z~tN#v{ku zNQSIp{HYO0dm(3<6@vkI=S;Jphew1_S)eIMrN{uFgAf}*MI*)s!vn#`XCpFsNLDcs z3@VceXfXlViSSsFndqd9O(!)OX~CcZX1hjG8L`l~3_?tFxFXQG2O(MlG&o>On*iQ%EMn1LHh$kf+86dgwpSl!-15>{+a-o5fJIm`Zd9V z9udn32@0N;G}&S%su-9+kB)^LDKttDm|s6c5PdX7V=NAgC|FCTY4z~|NBRJWGu(k*3<1jtkS8Pp z9St|2Yh%#Rw6+4hjHoXp8%XjC2?O1ns%(;xzpPW^gsBW0Dvb(8n;I}x3c?YQWf&4Z zhb?;15oVfiDS7Xy&K?p&Awfit2P1?T`#|6$fB`0ph@dxC2-pjtI7R@* z-~>5kAOR5(L2;}Ma1Y>#kRS|z5QJAj01*<92Dz|EE)hXFoS=#fB*-Z=t=unh(o^{W z4FPGs$>NHj3PBx&rU;TE0-AuusX$nyJ`7SHhLecFhzQOF?F7w5K4TFYV-e_w2)YE4 zk&hr5loZrOfB^zL01bcwV1NJ*ZWy8Ff&sOn>6~~#o)-aFHUI=xAwiCWB4Bes_yh>b z2J9pNqXWU++|9^{4TP95$G&gv!^Q_~kcl?Te3Yi&EPWGuih7bL?YqP{=fXCs%*MiV zCc+}GkC{{mkSn=wXkYC2l?&3yo&Acuzp{a+h+R{$Ywam|3*X3+EjRD!_Bt4Bwz6P< z@pOK&lCV)_%cq?6^xWnl8<%If-T^(c_gFpp7^ zla+@Hoq;Z%>f^F)1RNE*>R@IE0+BQt|LW;uAP-*QNkxRL0%4R`#N-i1h!7{J5W!Ll zRvuZf^ZXMr1P(dKX2OmlTE(!aG*lrIr%WoMLx>-P!iXjM(`hV92%-&%Ky8DS1zg#aAcz~7q;6D@3Aj|0Fp!*Mh(CkQqzAHy&Jk1^(SzzAOrwXiGbx?yp37FIv zNa#29Ly!puGCY5P_?IMzM4(lOsET6}!FqyNGy#Ax7Y1UZ(lmh224X|K3;Y;}TZ=>n zo*yl;4oL_2bTGh3MII2~Km#&JMh~p07lRVvM5j%zbsoVCdNdO?ib1{!|0Pmb3Pk#9 zgBNV<+}thQRd{ONUE7&!mcs5|x`qFy0aC`_(AzvRBrJgGP4;$M?Cln#r4Kxy!!lb%5{7FVqM1UXKw|^Gw1^k|P z&LCmp1UB#IoMGbr;byN}1K)t;)Df}Py_c(y;hEacH z!p!{WTmgG8=$CjTAF}gZYzjepfdZX)_TrHN^#r?e9{{Z&HxRM|o^~gI+W}}j=5>b} z@b7+%sa-74zl11c`XOJFaY6{mu?aar8TjHs5Cf=EAO@fl0(`Z=(uQbIAVfzq%|SFd z*aa{^4jS+Rgn=&$X6EJN-3JnVS4W-9mXN&>8p7^H&Jdc0}(0Xhz3QDs;Enu#LFa>xZkh-Ekmge+a3=7x*MF zlf1J;b09QB0G;VPcL#Md(O!pxazAs5^jn@FZPW*Tm?`?6fIb7znHoziKn-lzAZ;)* zS|FqY!iePg0W8dVy~tEt}qciKY&91R2ikS7l^1oRz1dxB8Ph%`iiJ|aC20$gK( zJO==${&gM`0TnZ}Ug9+Bh{P~ZZX+B)q%8pS90D~X{dOMDiAW71BNMX(!Nx}aU+upw z@MB>h7f=r!)Eo&Ug*8LAejef9&jsK&L&tX}ou5bfkH**(Eo%nk0htluVD^NeGw1J= zN9OVWJ%9s%5wpPO8Zv4A@A?0Z1Lzqy77M{i#)bq=)l}QmAs!4nwkXM14MZtpF&Hv8 z%t>HV zLSndtM5cBRz>J0KQ8B z3eJotQ8;n^zol(FFgMaRZXvv*vy0nAS8#vO6*vhaKb>b7HVBu5;R8dA;ld_?B|z7E#JPE3Mh&; zpIxj@PTyFmCA0B_JqByWV|-UTmS zzsxT4X!i}>+gI+wd)&Xrg%%{MosbJ+-TWMLoU$P=dyQ&G&`a?%cTf4hUEpNA7W;ZI zzN&-oMB=)S!!L%iZ0j?PHaD|xml|w{?EUUfoV&+h(9A<$#v{P=X!1e5%0Xyz56`#a zT0Z$>z?)}0Lk>%Q7yW_JL*jPzdwr;vSv{B~OkE~gH zoY^_wDs7`3$ri_a@k#8fyqA_4zjQ^i&#^OWte@Fb{aCD)6~EzuwXExot4)5z$1eN4 zZVB;Tm31J)lc;X!w0&eJA@gwhm*92tPsN&VH?aG3ZN;024D-l~NsG2h9$Q2K%IOqP zP9G%CI63c%YzUXci$6!Bhs((%p(^v$^}#AltnnG;?39zTC%7nvsaU=sBi(e&+Dw1a!(-@?t0H?6qf8KP&XieD~L4l z;zrA%(yaZ7PfavVboE|{fnp6hMlJ{RCzG{Z6F{t=r*hcx$w-pxi6eUgVkHV%Y}} z&&A4D-HA3|2iz*3cPy=VEWB{vs_cYsBh?D9@5}YR6})p~Mg>0fl`Zny(Z45t_uSiU z_FPfx2Q2X21Uupf_obHAu5ktv8jKTgifx**Y7?)ZIA#Z_eXh!mTylS4F|@weaE7u{ z(D`!L%{qeXt?6*o@Da7@Cfy@^u*aCP0;&oIs;bB;)#AUTtj4@~h+Lv#38WHLRf{K7 z6Hrw^QNgwoI8ap!{+_D(EoIj4G&aXi6B5;4u2Q$V=Se?EIE^j8l;17dyp<3lQlNEm zFo6Gh`k>!j$=J+R-vdXMU+5Lp(A{jg^ZiF}%3ia|f=#DfI#^d&k`+ux&UjF}35NBx$y!=u18pr}H))NdS_t}2nsk3T;Of81@zS}$=zvq)!%Mzg&+r?$(&A%H zb~&jm)N2ZNFy`{B$Y0iTGAhzC+S*pEPe}20@=Q`uWz#xgf5+Ls@4ANHdn=>93J&PA zb@A@bWt)}UU&I|;_`$kEZ-M^qqtV`FV!Jc02xNLLI9I{xgS#=IYE}SMvlQk-RD}=* zGm2+}!OfP@X}agPb`WB>O7r3Iz_?F^1qqzvdj}B=o(&}omV?PSEMjhrbdsHJD5dXs zlIJ^rKbgL7!RamySbQ>*Fcv>ch70)ZBEfFo0y3MS+;}UJd`&%-bDt>+eOGD7?D=pf*2+@T z=i|M~n@L)6l;FY&=dSfuUQb3^wq64LtB(8!<+t)|53n4 zdb{<_8)7eGFW`^f7*_9=P2XL?H7ulTdbs!NlLPVA_3XYjR9{o4YV$WvZ;wR9c5&%& zhD#-oWqWu%9zH7`erCgeI3RD-MU=FrkxeeHXNQ?`NYnPr9W5DMJLM{QybA|PDpP~k z&swQb9~BBo=N$eZy85%|`Z*^zcC6fQL)I*K@N|{Y9cZ1OO=tVYmb%&Bco`YzN{y

_N=fZKj$p}s&umk=5ZbE;H29G&ur2Yy04eP-=;Ci%{t~R>w)gq%P zvimhy`p=oaf2FBW3k1((C^4`(~g;p^`#?{qlKf{6mJ z*>8F55V6aaG~ZU4=M5{}gF;`dZg`W%&Nsx1&l^a)DtkqH&W2qdJ_bpte_!3VQTkP% zQ)%%z1^3pBZ&n?g*H%2k zcGhCr^_+;5C14dXqQKa^Az2 zM-NBeZ;y3##MF>jtCoe&5<1j=W_4yA>84=G=5W6{FYFa3qL54e!#L9(ullOR1yWC> zF{u^xF&{Qvdov%?-*YCDi>*1swr9Xytf?TpdERgkOu1Ot@^) z0QY6}`VNaD&%VA{d+h1n{Vd%&r;Do;1eKz=7r1R+wba@|`1Fw@)s8{Ud(1}@V&xKc zi@<>|%mr6SH1C#|yJqoH?PdK(+pFp~yR;G7C|TU~O>?&iX_07Xi%{tZIZ0(F zoTQQq{IM{YZvUJM^!FaxDF<;;;uFMN8+Rmg;>fe6xrgz<2Rr3H<|gyP(^EwdV{oD% zo(zn^9Qj7cjlJnvL5CB1#CNo(Rp}e)!HEgeXv`ur;E19H35LHtX!~1-P{nWpY20cH zqW|PL3ycm6p@nLifUAk2c9uqDJp%(RgBi{r;9SKgVW7R1R?VBQtnGL8^Uvl@@1Y;~ zmH=IJ)r@bC-DQ<#TA!lw>4%s5>q?%OhX(z}Mp{Y;r!T14S=B{FaO*}cQf7(1DbO!b z&?^^XoR0q5{i3!dB|5N)@S!9+-!X;f?1h31myKKB^p}W~Jrb*H&AP-j`pHPwR@a=!*Hp@L~NH)WRA*rluF&XJ0=m>rpW*+B1vSmS7r^HN4o3Ku@SA}XBcV$jOdH$SJd zE$SHE$8jol7tQ_7<(IE=KhLrv@vQJv;&9a^CI#uNcd^zg&)jKbx7z7IM=wsHPIH!| z0JQeCuCRu+w{^1^ubh*?E~CZbSmC%Wjr)dP#boN&uhEezPEs6(ldzIg14tkzVP}CT z4pd}Q{xK5)JKbwHO-`4?v!@!1BXdt8>=+=WlXA#L=0lzQh{Io7XPypu=`T_`$jg({ zBye%NeW9H|*FM9!W?wmyf3naJ5!rguC*6hidiikNrMjc4*)QeKYqnxF3OhAkv#>Gh zIjU~_m*NzBa7_})D%J+~mRy50suef0sorlpRmH8!(R4<>IB;PLpWaZyv9A0zi@1(% zG`Yjtp?P}QsNu(J%j1(I>vGz}WXu#8O8Zr6P35%D4!o#y9ey|uYi3cVU9t1q*0zs6 zHjTQ6R|Y=%aX@-wb2oNWW`(GzfcNoF^ZSQB)!&HZs^pQXx9)o$vfah%q_34+ez4U3 z&`^>2cLZEWCMAZP1 zA@diVJ0L<;OF>@O|iQ?#q{l=rX*y90<%fi6Vj%0rL29lpZk6VX_YDRv~MX;YsvA?Q;8W?Jnb?29AWSSnJ%V^tM9` zgT1Si`Fg(Be!1}e=-oXDAD&sHdyL5W)4tfo$+SM$_0gsG_OEsgcxA1Bq- z9R4Z-t0kM2GV2Q>cFZlzRBCHCXmk+Q#1$UzS6y1MZE&8kK+lJ{FI`GZ+qGsZvp*~M zPdrdsHVEAvHoQ@YIl?H_#aqRkKGTrUsS+BHHrUPDDs(RSy47t{`h9PHjR_lF9oXn9 zV-5{P*qBwadg~*-{0yJPf4Oky_iclt63!Ea0V0YMc z0tZf!iLn@MO`O5->e1Uw)dzL_FKShR31M;k7`vnA&S`s|~&JE6SLw%}K_~#P{vy z(n%h0JMDCK)uX3bCz-KaALi*C;#arZ>kA7IB{m7ces8qL0n7&yoLs;Q; zdv?YCl;fZ8YYt>FywaBFJnCFnx$^5Q-_Ot7Hkm0qx}4Zo<)yZ@=5*dMUpR?94k&TI z34aOi*6XO=#{DELaN@>)i{b`8?J>nYcS>>pu~U3Xg_D8C*4Kh{4aPhx^H3BV=^>t# ze|m{Y!v1=f0E^ruz=FF3V9p&H_{QLuA|39c9ZceP)H(Ix_+q&|=8~$RFPFL;tRv`4 z;O$PuH_eiHs26%ku#0;@|9n27y4m0sMwo1VBaJ6EV8gm>-#KAbyX^{J2Cul@z0jDM!nE-QxeqdJH+AAam4b(@~#UcT;!qP!7Jf|hTg@Z zAFWS4)(@zl1?a}?EAr>lxM8~e%hN~fJh!}K%k1X%@ti3ViawKV^ltd6+ERX5M^BZK zIL2c^!xMHZy57FE$Xb7Qb?xd@$-Blio0q>xb554{P^`J6ck6tOO6|oLPZT?y)+oIJDSbQPNnXaVu=rwaKFiz_5w`FIMKnla=vaLui8bM}VQXXRLm zKC@MhUsYDoSIje5IIm+(&9+J@h4KS|Zz!@WpQzaF^4ZvJ{EP3-OL^U2pYg`g4lX~mrTfjYJyqWyRtNT+%S~MU_V!!*KD)W)LMr>p*9Ij# zPxp)Qsntxr<5lS07_Fl6{%v@ZN~U_Ish;z>Cn=U`7dRa*-Ym1wWbGKDeTgA1Ru@|C zyQ9F^Sv&b&^+vHryPZDfRG+pk3d_6x`1Z!llMbf0VDWkh|LP-}x=8Wc#pq8w`!k$R zznnWvzk$KfFvOC#TAUPSb9(Zs{4%*yAx#I|lmM%REFP>xuyc`Pk$tM&-}n22=?ms9 zaLt1gtjU$g2iEq{(n1%z6%&gaSnS+j7uab62aBEg-#Y>L6Z$MTaSzgXB0ez}PRxcA zvnD-nBpk5mV3UdJuozM8KdTN|yaVX|OmMd(Bpm!&!#{!vwz}c4=_COxtRtgEl%95x z)dyT-MK1gzSA%20Wo_irE^>VuxnMbV)tN+;{z;*tt8dVU)Uv$C9p7|qN!|EM6QeVH{f{#yFSuIgH`*L19Sphe-zcwJmb;vqymjp+ zYnMe`v$n0dE@3YFpvBTCCQe~cXzjkO zto0cmuP9-yRnMpM*Y7>RHf!hG;BUdC9Yv}ps-cVR{AD>qXiM{Qde?tEn>lE$_UQZk zYYn>ZXo{83s+8YedpO8jm9LVU=g4cs{edIxwrrEu?4E&(8tuz=AGI^!y2N$<(&5Ty zwRi7}Y;?6+tgp37St7pXqw<$W>W0LSyxJvc;HN9)Cs<9UY=nInRTbkT6CuYy?z2Z6 zKRwBem!gZTwJMK#W~xdpZCdW;m)a!lKQA}6``+M}52D2d%1_$LaKFHzs(=7sm)_$;G`hUmY8h98ZRkkso^uW1;VWC*m_j^pE^Xu_kuPwP$VYU) zzvG`?xW@cczuCV{+ZGmqT{*Zs$Ti_}633H)UmNq^_g`sF?qxagWO+O>fvx|tW22IW zU{Vi{7dMzj<39>=rXYdZKZTNGl3moHNasUUQ&=Xj`QHX>n==68EU_R--TX&nQx>SycQ7PkA`vRmWVO3*&< zwk&1q(yTjrx2|_4Bs695zf--wmsfV=S-n^6i(S{*u9B6r$qY>x-(tO9qQmDbJ5Fm< z-7RQ$c{JdKQ}7x_C*+DB_$!hy>c9!40#?a6K*YvLCokc`VZhbCnVt?j zadCQslDG7_1rLK8S_K>>u}40H2At}$v-iZOC+7Md*tRwwkQYh%7C zl0FRlQ|zFE1T5xbQR2zHiO2u(8(K z9y9L=BAX2u2;Z;9{Pc^#2c&sUM+>AI65o6m%Kh{$J|sJo<-vcej0;Li8GgGa*k0Y| zV$(Cq`KS}dfojVJMBJ6}WLYywi5=4IoI+dHP~assuqEGn-;K#07PIa+*6DK`F@Lzd z;x-fZQc5bd;<@(flTBh<;~ZbD#lF@b7Tct1CCjiVL0LYD9yJ}?9k!jjuy1)MMTn+y zN#bj2LVY*oyY)F`={Z4y3<X-R#3;HxIPnCas5YVs}bB@Tl zJ*MsZ>9Z}C%U6gNV%VJJ9Va|7&jF`;{?wSg1%AJoPTo3bv3iZQzz4&b5&#frT7neYnPfxeaMepnB@jl>GO$w(u_@{-aT+EwD)rR=hirgZVy||kzdg9 z7FU*&xn%C?<0JSd5qq>2DvvCx()@A!*%s}3Kc9m8UZyYKx910L-8{O|FaF`hh1^+6 zJqB;Y7q0T(wOTH`sj#$U!MFIeIV-ou>&{tr1PbTo}!csTq)?{wJAurc&)Ac+Pk&u z2cFDd#o4`_l_$?ZxmWEXLvMKh1nTZ1v+vz*I7GFHdGTex?V+JZjCGVydh~(BE9IOO z2K8?)UFk|X%4n1RSeJs4Nf?$)Q}r;YU3RaTXHkCK2IhQ@=Xn~hG9GJ_1m}J_tLdRE zH`H9=bWf$O=D_`&+H&)fmJV?<$H%E(RSQZ50^u9=EG_$P|J9%J(={b8%T+BoR{6kk zL9WZHJH^*8E_xdB$m?9^Blzsd)#r}GJdMkpU+$6-*VjDVv6zkYj;F{)_ue~BWvN?7 z*6GS{oVqvf{tchZN34x@f?&bv1cv}8Cl(#So{i|DGvm+?@%{g^ntbesC|X)Dxb_XM zevkbSMHfM}5%fQE(f`Z!sX_0Pzg4#1)_OhLWwEKTG1QLZG|XJ%xfyjQO2oespElXO zw(a*cA?!L59_1}P+TPb9t9RFHv^~}#w;Zd?zE)V(;r6SeYZe;1$CV!xS>zo~JXw_V zx!aU#^=b~6#Wprf#13DZ%GTy3?~T9MZhgDH&pbv7AH2ZugCqkc;QM< z`BBSnBv&ijU@cZp{)(h(tItoZMS0Y&%(~%ZXLeo7_tb&~23-5jOVy@C4Bq_w%RIabl_AC?o)LHpNaJen4%c5X$JuVlHFYw?-oeEE4VrmIr#3w+f566 zXB-6lcDec&f1?5n3~=8Y`Hjlhq5_Tr$p2G|${*1F`3&H%ZqJ|x1K?*YG~zBEvzsc< zLi5w0=Lt?wTW4|F)0*G~g}Oz}$ILBms%X9mh~-_oWh9ut+{NHcn7={rp@pU9o)0n} z3}3F=`cUKt!DhR4N*n!)@kf`tE22y3#U7=Hv#OPTIM{q%G0%^L-4#8+;thK*8~iHH z$1^QQVV~g!#lvy@H|Wr|%Z{QM<{^yBOBWpbK5W)|%TljA4&(Ut=9$CVdGpsgwOB}0 z9~M3wewmqko0ZF*lq>l?WgzTIIPaD{$r#Fu7~F&Ilfr~6BH#7+`y;Fv1^Fh6h^BVS z<3r|e&V!F!5T?7(BDQ1|-R*zUzG`Q~#?UAgaRX1Gv}b~s&*q%}uygIzFZC70Nw_HB zv0Z^~&7T(k2k#3?6uH0#ed-t=CjtpBuW}2BS}w{L`XnIX;JbpaXSg2}C7y>98}}xj zh7(WzTP*Is{QZlQhx^#?Utldg4U2i!`Wj?QeSNYTJa^1em!D~=6UYAA2houN{`wJv zXaW9~Z|L-G4){S9mJPajdC&lspUpS5>(kcNA}^hc(ACmLBVZP6IJLzDNA2pcD$F%b z066WDEh2=)5)#J)BIaYMEtV&d)Opj&V#(k*dh(hMx?wHig2AN@@V9(KpZXS0gxQN{ ztdJ8wAPX6Ovu&7uy;X?+bDBujWhbfmvZEf|9~94&gp<{>wtq6`bG|s5p&z$IB`&a(4EyvMt+5k+lx0z9~pQzLK=FW8Fi^FrK;3J>ym-sE4EUZ zO*<14HyhTS1eai*f|=Ki&b;)0)@T4XVP;q}Gd*E*VTnoS2DrAxGsArW|LobKIDY@S zw#?wR+QD6SK801Uu$vv;pK-80{_SUSNs;r9ZaDGoGy>RJq?Iv)!3iirJ(sh@$OqjQeV5d(VWvmv*1zb$FKBepE8s&=e8pF1Yfdo zEeLyRk-1b`IHQ=lJh{Nnr#WzKWr>$DDPQc}{f@NHgqv5tm-a~WJi)fk>kCcwrTgrv z`yyW(&=-)V;>>A9-F7&>x6UVpR1hG4CoCvdS8?O&FWj4blIM4e^KDYOGgPCYlI7Db zUe@)b{?_FOp+1+06{;t`cvrqGA$)7S&Oc1wLDE|j{n&Nq3+`i1=H{XO%vHlRer1~e zB{%h-4;tN1<>$8%&VQ)0x>_!%rbhE_d&?W$^}f}G_-$)B3T0EkFX9a5C#FKs{{sfm B^pXGo literal 0 HcmV?d00001 diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/NetCore45/System.Reactive.Interfaces.XML b/packages/Rx-Interfaces.2.1.30214.0/lib/NetCore45/System.Reactive.Interfaces.XML new file mode 100644 index 000000000..30ff445df --- /dev/null +++ b/packages/Rx-Interfaces.2.1.30214.0/lib/NetCore45/System.Reactive.Interfaces.XML @@ -0,0 +1,336 @@ + + + + System.Reactive.Interfaces + + + +

+ The System.Reactive namespace contains interfaces and classes used throughout the Reactive Extensions library. + + + + + The System.Reactive.Concurrency namespace contains interfaces and classes that provide the scheduler infrastructure used by Reactive Extensions to construct and + process event streams. Schedulers are used to parameterize the concurrency introduced by query operators, provide means to virtualize time, to process historical data, + and to write unit tests for functionality built using Reactive Extensions constructs. + + + + + The System.Reactive.Disposables namespace contains interfaces and classes that provide a compositional set of constructs used to deal with resource and subscription + management in Reactive Extensions. Those types are used extensively within the implementation of Reactive Extensions and are useful when writing custom query operators or + schedulers. + + + + + The System.Reactive.Linq namespace contains interfaces and classes that support expressing queries over observable sequences, using Language Integrated Query (LINQ). + Query operators are made available as extension methods for IObservable<T> and IQbservable<T> defined on the Observable and Qbservable classes, respectively. + + + + + The System.Reactive.Subjects namespace contains interfaces and classes to represent subjects, which are objects implementing both IObservable<T> and IObserver<T>. + Subjects are often used as sources of events, allowing one party to raise events and allowing another party to write queries over the event stream. Because of their ability to + have multiple registered observers, subjects are also used as a facility to provide multicast behavior for event streams in queries. + + + + + Scheduler with support for running periodic tasks. + This type of scheduler can be used to run timers more efficiently instead of using recursive scheduling. + + + + + Schedules a periodic piece of work. + + 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). + + + + Provider for IStopwatch objects. + + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Represents a work item that has been scheduled. + + Absolute time representation type. + + + + Invokes the work item. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Represents an object that schedules units of work. + + + + + Schedules an action to be executed. + + 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). + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + + + + Gets the scheduler's notion of current time. + + + + + Scheduler with support for starting long-running tasks. + This type of scheduler can be used to run loops more efficiently instead of using recursive scheduling. + + + + + Schedules a long-running piece of work. + + 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). + + Notes to implementers + The returned disposable object should not prevent the work from starting, but only set the cancellation flag passed to the specified action. + + + + + Abstraction for a stopwatch to compute time relative to a starting point. + + + + + Gets the time elapsed since the stopwatch object was obtained. + + + + + Disposable resource with dipsosal state tracking. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + + The type of the sender that raised the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Represents a data stream signaling its elements by means of an event. + + The type of the event data generated by the event. + + + + Event signaling the next element in the data stream. + + + + + Represents a data stream signaling its elements by means of an event. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Event signaling the next element in the data stream. + + + + + Provides a mechanism for receiving push-based notifications and returning a response. + + + The type of the elements received by the observer. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the result returned from the observer's notification handlers. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Notifies the observer of a new element in the sequence. + + The new element in the sequence. + Result returned upon observation of a new element. + + + + Notifies the observer that an exception has occurred. + + The exception that occurred. + Result returned upon observation of an error. + + + + Notifies the observer of the end of the sequence. + + Result returned upon observation of the sequence completion. + + + + Represents an observable sequence of elements that have a common key. + + + The type of the key shared by all elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the common key. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is known. + + + The type of the data in the data source. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is not specified. + + + + + Gets the type of the element(s) that are returned when the expression tree associated with this instance of IQbservable is executed. + + + + + Gets the expression tree that is associated with the instance of IQbservable. + + + + + Gets the query provider that is associated with this data source. + + + + + Defines methods to create and execute queries that are described by an IQbservable object. + + + + + Constructs an IQbservable>TResult< object that can evaluate the query represented by a specified expression tree. + + The type of the elements of the System.Reactive.Linq.IQbservable<T> that is returned. + Expression tree representing the query. + IQbservable object that can evaluate the given query expression. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + + The type of the elements in the sequence. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Represents an object that is both an observable sequence as well as an observer. + + The type of the elements processed by the subject. + + + + Represents an object that is both an observable sequence as well as an observer. + + + The type of the elements received by the subject. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements produced by the subject. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/NetCore45/System.Reactive.Interfaces.dll b/packages/Rx-Interfaces.2.1.30214.0/lib/NetCore45/System.Reactive.Interfaces.dll new file mode 100644 index 0000000000000000000000000000000000000000..808334b428e9b59a081031942195089e8345f027 GIT binary patch literal 24136 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 B^pXGo literal 0 HcmV?d00001 diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Interfaces.XML b/packages/Rx-Interfaces.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Interfaces.XML new file mode 100644 index 000000000..30ff445df --- /dev/null +++ b/packages/Rx-Interfaces.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Interfaces.XML @@ -0,0 +1,336 @@ + + + + System.Reactive.Interfaces + + + +

+ The System.Reactive namespace contains interfaces and classes used throughout the Reactive Extensions library. + + + + + The System.Reactive.Concurrency namespace contains interfaces and classes that provide the scheduler infrastructure used by Reactive Extensions to construct and + process event streams. Schedulers are used to parameterize the concurrency introduced by query operators, provide means to virtualize time, to process historical data, + and to write unit tests for functionality built using Reactive Extensions constructs. + + + + + The System.Reactive.Disposables namespace contains interfaces and classes that provide a compositional set of constructs used to deal with resource and subscription + management in Reactive Extensions. Those types are used extensively within the implementation of Reactive Extensions and are useful when writing custom query operators or + schedulers. + + + + + The System.Reactive.Linq namespace contains interfaces and classes that support expressing queries over observable sequences, using Language Integrated Query (LINQ). + Query operators are made available as extension methods for IObservable<T> and IQbservable<T> defined on the Observable and Qbservable classes, respectively. + + + + + The System.Reactive.Subjects namespace contains interfaces and classes to represent subjects, which are objects implementing both IObservable<T> and IObserver<T>. + Subjects are often used as sources of events, allowing one party to raise events and allowing another party to write queries over the event stream. Because of their ability to + have multiple registered observers, subjects are also used as a facility to provide multicast behavior for event streams in queries. + + + + + Scheduler with support for running periodic tasks. + This type of scheduler can be used to run timers more efficiently instead of using recursive scheduling. + + + + + Schedules a periodic piece of work. + + 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). + + + + Provider for IStopwatch objects. + + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Represents a work item that has been scheduled. + + Absolute time representation type. + + + + Invokes the work item. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Represents an object that schedules units of work. + + + + + Schedules an action to be executed. + + 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). + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + + + + Gets the scheduler's notion of current time. + + + + + Scheduler with support for starting long-running tasks. + This type of scheduler can be used to run loops more efficiently instead of using recursive scheduling. + + + + + Schedules a long-running piece of work. + + 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). + + Notes to implementers + The returned disposable object should not prevent the work from starting, but only set the cancellation flag passed to the specified action. + + + + + Abstraction for a stopwatch to compute time relative to a starting point. + + + + + Gets the time elapsed since the stopwatch object was obtained. + + + + + Disposable resource with dipsosal state tracking. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + + The type of the sender that raised the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Represents a data stream signaling its elements by means of an event. + + The type of the event data generated by the event. + + + + Event signaling the next element in the data stream. + + + + + Represents a data stream signaling its elements by means of an event. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Event signaling the next element in the data stream. + + + + + Provides a mechanism for receiving push-based notifications and returning a response. + + + The type of the elements received by the observer. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the result returned from the observer's notification handlers. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Notifies the observer of a new element in the sequence. + + The new element in the sequence. + Result returned upon observation of a new element. + + + + Notifies the observer that an exception has occurred. + + The exception that occurred. + Result returned upon observation of an error. + + + + Notifies the observer of the end of the sequence. + + Result returned upon observation of the sequence completion. + + + + Represents an observable sequence of elements that have a common key. + + + The type of the key shared by all elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the common key. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is known. + + + The type of the data in the data source. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is not specified. + + + + + Gets the type of the element(s) that are returned when the expression tree associated with this instance of IQbservable is executed. + + + + + Gets the expression tree that is associated with the instance of IQbservable. + + + + + Gets the query provider that is associated with this data source. + + + + + Defines methods to create and execute queries that are described by an IQbservable object. + + + + + Constructs an IQbservable>TResult< object that can evaluate the query represented by a specified expression tree. + + The type of the elements of the System.Reactive.Linq.IQbservable<T> that is returned. + Expression tree representing the query. + IQbservable object that can evaluate the given query expression. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + + The type of the elements in the sequence. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Represents an object that is both an observable sequence as well as an observer. + + The type of the elements processed by the subject. + + + + Represents an object that is both an observable sequence as well as an observer. + + + The type of the elements received by the subject. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements produced by the subject. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Interfaces.dll b/packages/Rx-Interfaces.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Interfaces.dll new file mode 100644 index 0000000000000000000000000000000000000000..808334b428e9b59a081031942195089e8345f027 GIT binary patch literal 24136 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 B^pXGo literal 0 HcmV?d00001 diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Interfaces.XML b/packages/Rx-Interfaces.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Interfaces.XML new file mode 100644 index 000000000..30ff445df --- /dev/null +++ b/packages/Rx-Interfaces.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Interfaces.XML @@ -0,0 +1,336 @@ + + + + System.Reactive.Interfaces + + + +

+ The System.Reactive namespace contains interfaces and classes used throughout the Reactive Extensions library. + + + + + The System.Reactive.Concurrency namespace contains interfaces and classes that provide the scheduler infrastructure used by Reactive Extensions to construct and + process event streams. Schedulers are used to parameterize the concurrency introduced by query operators, provide means to virtualize time, to process historical data, + and to write unit tests for functionality built using Reactive Extensions constructs. + + + + + The System.Reactive.Disposables namespace contains interfaces and classes that provide a compositional set of constructs used to deal with resource and subscription + management in Reactive Extensions. Those types are used extensively within the implementation of Reactive Extensions and are useful when writing custom query operators or + schedulers. + + + + + The System.Reactive.Linq namespace contains interfaces and classes that support expressing queries over observable sequences, using Language Integrated Query (LINQ). + Query operators are made available as extension methods for IObservable<T> and IQbservable<T> defined on the Observable and Qbservable classes, respectively. + + + + + The System.Reactive.Subjects namespace contains interfaces and classes to represent subjects, which are objects implementing both IObservable<T> and IObserver<T>. + Subjects are often used as sources of events, allowing one party to raise events and allowing another party to write queries over the event stream. Because of their ability to + have multiple registered observers, subjects are also used as a facility to provide multicast behavior for event streams in queries. + + + + + Scheduler with support for running periodic tasks. + This type of scheduler can be used to run timers more efficiently instead of using recursive scheduling. + + + + + Schedules a periodic piece of work. + + 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). + + + + Provider for IStopwatch objects. + + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Represents a work item that has been scheduled. + + Absolute time representation type. + + + + Invokes the work item. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Represents an object that schedules units of work. + + + + + Schedules an action to be executed. + + 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). + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + + + + Gets the scheduler's notion of current time. + + + + + Scheduler with support for starting long-running tasks. + This type of scheduler can be used to run loops more efficiently instead of using recursive scheduling. + + + + + Schedules a long-running piece of work. + + 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). + + Notes to implementers + The returned disposable object should not prevent the work from starting, but only set the cancellation flag passed to the specified action. + + + + + Abstraction for a stopwatch to compute time relative to a starting point. + + + + + Gets the time elapsed since the stopwatch object was obtained. + + + + + Disposable resource with dipsosal state tracking. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + + The type of the sender that raised the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Represents a data stream signaling its elements by means of an event. + + The type of the event data generated by the event. + + + + Event signaling the next element in the data stream. + + + + + Represents a data stream signaling its elements by means of an event. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Event signaling the next element in the data stream. + + + + + Provides a mechanism for receiving push-based notifications and returning a response. + + + The type of the elements received by the observer. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the result returned from the observer's notification handlers. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Notifies the observer of a new element in the sequence. + + The new element in the sequence. + Result returned upon observation of a new element. + + + + Notifies the observer that an exception has occurred. + + The exception that occurred. + Result returned upon observation of an error. + + + + Notifies the observer of the end of the sequence. + + Result returned upon observation of the sequence completion. + + + + Represents an observable sequence of elements that have a common key. + + + The type of the key shared by all elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the common key. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is known. + + + The type of the data in the data source. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is not specified. + + + + + Gets the type of the element(s) that are returned when the expression tree associated with this instance of IQbservable is executed. + + + + + Gets the expression tree that is associated with the instance of IQbservable. + + + + + Gets the query provider that is associated with this data source. + + + + + Defines methods to create and execute queries that are described by an IQbservable object. + + + + + Constructs an IQbservable>TResult< object that can evaluate the query represented by a specified expression tree. + + The type of the elements of the System.Reactive.Linq.IQbservable<T> that is returned. + Expression tree representing the query. + IQbservable object that can evaluate the given query expression. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + + The type of the elements in the sequence. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Represents an object that is both an observable sequence as well as an observer. + + The type of the elements processed by the subject. + + + + Represents an object that is both an observable sequence as well as an observer. + + + The type of the elements received by the subject. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements produced by the subject. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Interfaces.dll b/packages/Rx-Interfaces.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Interfaces.dll new file mode 100644 index 0000000000000000000000000000000000000000..906f729cf8acd20fc8ed6d1ff2bbbf73ee5450d1 GIT binary patch literal 24144 zcmeHv2|QI@*Z8@EIrFS=k<8b*W-`w*hEORkE^fG&d#^ENsDwyJ3Y9TUL?{)Nq#3D{ zQb_Y8Mf3FE=NNnHdEVz6-rw_mzwdwQtaH}d`>eh9+H0@9_S*Y$UbY3oK@fxo_m3YC z)C``;WsbtX2FW0qPxd$;)X3E-*Nk!Ml=BRwG6|6kdI*CYK?o$%Xml1KfI?tI(+E@= z!P?b>5J3;35P5mI=TEYBvw@%Ob8thD z0Q!!ds5e4D>W^N@00R1PJ`8A=`358_@_*(zi6SI$?FD>2kQZ}svmq~&7XgCYOu@T9 z1kC}DNNot32cCcXB1~5u{e%#8GT@$dnM07}EEIhmLgWfAq;6PH$VUPM#R)+W z7ebtMxe*{Jc^3X>uWuIj37^b$fBdRirX=lDIB~zyjj-nmBd0KDBh?(jEIzK=sgo^h zJi_)J8txe_cW?M|lD1edXTjd!qzbXT#g5IZQg)|rI(lLM7oKp1)%j)-<-JzQMzr$s zH|6H|P{%EA!~BjF6@RZBe2 z*`X)^`JgoPy&HXhjKa?-g@Qx!Y(?Qt6rKl=4;sha#j!&L_|!{Mp!{!)*Bgo?}CJ-bLx}P^ic*#Lk2afjrrvPNkX9pU0VsyZ0>Rdz7-9(!EFZ<#pfZ3TglqxCfD#ex)Fj4%V%H`y zP854EiE*RY$Rx&xVtC917k(7u#{{4}1yF1*Mi0dVQA}+T6GkzMNlX;Q+$J$`6!XOZ z1p_scLb0exY%YqenZ#sJY|~HJZcIMI@Q36#X(`i|=NuajS2SVIkThO#+kYU#+HqH3IRhniB;oXqhoR+?GPvd8LcSBdjga`gI&SBpN0Lv zeVK*v;UUa)PBs`XG7B@t6EMhRfPt)m=&;Zt0CCV_0H-Lk-+g{b{gpD2-yh}hXD}E| zjl}Z;xeI}w5P^`ka6@9?76)<@2Q&$gA_3kd04)Uy!zyAjP?(Ft9VjeA;XV}Bqwp9C z+W=I>Tts0HO1X`~`v7WU-Tfs_SMYnzQj+>UIV6sQXZv=|F?5C`!Bo#g`-MF?19Vbm!(k6jG%y~h>+sDL{J zpb-x7o>t-zIu6?gU_1Ig7taQU%{Y!5KqWjsh7)kWg3?3)!~$M8@Gb`Ub3&p3VnLZ~ z0P=&9kX&2<3IZ8mLD{?jN`VwCkb@wA^H5IG;5%VJmxGj{tI&N2pN!}auy!$s?tpq> z_5jO@*vu&h2Lp8>2|v-eA$@c*`8i(#N<;GULc7p+A?OkMt@tD^Ir*GB`J4xR!5|st zLA+>w=}EfGBu;=NP`W%Mg+=noLvkoSA5uZ_`4ADsl_&G5PdLsg%L~+q%es=;o*=AIfBBB1gJG| zoBojZk2ukaP791?FetRZ_+Qejsmw?^lN=CEVg8clM5RUjLiC6ZSVakBF(C(!z)%WO zS%w>hL8S*#0|ALekBlX=0z=&x^cZRog)x&W$N{v+pEN_5mBw(Q(?Z;%X*A%U%whsL zSdnRglyIbWkb_MOg~oCtvw$3E{#rld9`tBNAO+!$=9)oW1DF&>426MwV8@_GM^b_& zNC;1axEReaQNqkS!f6JZX$+7g4KyCfK8p>~s0pbc9H(AMPy{oO&IqRlOv(^)MI{G$ zS_ClZ;n6J6rWxr&o*on$A~3W877XC0dCq!;JiW-_(GjRe~I5-a%VDCj>G@1>zt<#6T9E0eMm*C?1hy+7t^bI)eh)M$-a8OQ!mFx_do6 zSY%LZ02!?5o`ymwEI;dL3c?9;pvBO`D9{vY4YDJ2*Wh3#g@xvHp~p_}*PiANAv6o1 z=5(ZAr%Iiz5=ap?;p9jrB?y{&A~Xl)ga83~)+>@SDNOW3L~l@m&X%w}nHB_87YKqJ z6y)bhb3qm~3`zt&hBAds5+`d$f^6afDUnDmAy=9Wg8`)HO0%LzM21sXpaMuyNT;A3 z6CX)I36mYi9wZ!GTji$Okq<-B$~zoJx27RFp%mY1JaYs0FAQ+i(*PF zoe^fi0_%tXM17||p#+D6L4lNG!DLb*0>a}xsjP6yOvWj)HH8_-prSJTH4)T5m>Lqz zAS0Z9mmC4~H2&8FAdH~sK-RAbR`ket1~nvfR?>8hnW({FLN1hO7K0oPM%4ttiA)QL zCWp+b`_w0sazX7dJ<)xP)hY z_X|yKCLiD-D91njxe6#kNC)95iKIw^DqwNS5Edy9gOrEiB49A0LK>i+pt{Iof4Subj!H z(0mYsNrs@UK(6eF-vMxU4-0hpf~-25zHWJfO$ym46Kj++kYR8^`Udtma=k}=3H)vR5x6QzKn5vqPT}?Yh?Oi)3+lqa7 z#N~;`K$;%Za4-vpBcoA$QpZhVbcnDz7`?$jHBG#!v>AU(IPH)@5D#!y-6snU$P(&EW*PHsDWb=z-)r} zIYEFi@YC5SGz}2hfe^eMr z(uGc&p6@(E8K7%WUVz`2KnK`O*Vc z`2x#DAu}o7Zu)+s?oiK&{{G5ts&QSe;M`j%!j)-N#pQKRG z1pt!cha%vEMu%te|6hJX*1%{yGWlmIOvK+{2>OMNxb;$MG9R;kEP!h;p-)YA-2orvor<7D<_4G;|AN`@GK z4;92}f!_?#pkRoOW}6Q~{Q$VUg*#8rpKgDe3=#P-Uws>?FB8yfQSPfiU9v8;A<8r1&m+tP6lxYq^ub5P5|wW0~nHnIaxjv zP?5SKR0gOqlAi)n2_Wu51^kgZGoW~Y2cq?50UW8{L>&oeUM9*BDTNH$MnKd4$Pbt? zCX9h6T8bzuQsu23Y(odD!V0jZ(jD>^8J4kSbc z6egq&av?1U1S@d}@&}O!%(U#R(Hsa*D&R9)<{qGICfe!<@ZBFJMf|NykUAQG=*tX$ zFTkGx_{{XB7T^Y!VvsiI87=Up1KttM^9K=i%q*@nR8}*s|IgHi2qYQ~{vp?P$O!Ov z0`&<&IV0K-3EGIXJOoIM1@i0zlKQX9m;ks~pyd)~aYrZ2%>F4pyd!K8ELoc zWKKkD5FMEsB?var`~TJU+k@y8266-C&_T)3KpR*;>DC{6`1fN0glo|L{h7}nd->1$ z*c|=V0_X!WA|k-(2}eiH-}xRH$N&EV5&(ig_P-$A|1XXIixNQhxUpCWPBk@Q=Tc3x zPy4`&;lP%rni2s?6^p@;cwjDeHZ?vRR*DURo!Gh6*fDrasy-HjFExdYVewfMewYh~ zflBe^*klNnoAn)DL{LT3ul&AP!?|P9w`6HIarzkc=cTEl3*c1z4mcH;Qi{W3uvlT> z3PU?(vXyF^$NCI_g#j4MJ6$mh8>m7&S|i*NJi9Py|s@G!97`JUfgKj;D5fG6!wV$B1q%bwN-N^$z})PdK(*P}IB+;v8X@xG z#qc5ni|@{TE3=5rOlV$POM3%FJ(q1eEQ=&7;3Z(OWRc5)PcL0-6!XDc)F*0-i5+t) z;+BQIkPNbTSJ)YLEOjWgOS1`Ou_BE$H3J#p#E7Z2EisTDp&1!QMW~vQ6Hz#(CeS}C zdJs@MpmBb%frd6oLklLsM34zyHdRLq2JZqp!HcGF7@KA~Sww7X?C*-8Fj#-Zn>AZy zz%TxHh>cM<=aGl6xC9+# zntfWWr1Re0%+BgGUrMA$+cr$O|}_R^;FAJS!>f6tw>+m(as)q*@)!&XVmN57OOwRbXdl9sJp@7HuP(e{zuq3=Fw zxk(%E+R832xY8a_)^y(Q#YL)bRPMfPFM_&}Oa8ZF_MDo`kD+T99*?)oH*|P+b>+** zY|H45)FoTyHZ36o<8&Mtr}7Eo#7)L-wnQfh**^#ij{UccdpT6mfK8H^u}R2ofCkt= zh=?T2SR@i`sHLT)t7|Y}k#wd}IHlp=QnNo;Bqdl8C_FGwGBhh{WGIC}u=cPa*m$@Y z+3IQm4c6D!*D$cq*CQ#y3P?tr@Vwu)XfnL|FD=-%mz(XJJ)j9m@y;?~~4n0sl_g)54k{VN2C z=j*cG@vE1fq~T6$uWM2~du3V4+4egD ziq0O2BIKMebBA7jusfG*^H|qIK`-`F-M#HFNkj8tc>m?<OB){FE9VZnZ=6UEJyw;&_`t$GkfQVa)XCXyuL+sz_!O;21T4Oner9M7K_ z$L@4++S3Y5GgJ_j1UnZ5i)dCTodGsJP`?R=4YWyGS|melEnuazCQ&T}{U=?zf8{J4 zW-RrUgo92=7x@zimOElR!cFJiq+hxG=6TrnLNS4%K_k{WsiT^uS}%VLoUwFK=w(3t zy58Iwmud+PN z>rBJUUE9xdjcnk{a*f~< zb}>m*u`gltjD=rndl^~bo#(w~Yj){ed)%@Q-4!9+tSY@%8k*u49y9cX#_9FOA*r9- z4`*wOQDpcs?+FY9jnlhqZ(J9D7JnAsc>Rm|pls%@gWO+)mCS1%e!9Oe$@T7h5;~SbF!Wy>=wcqPq{GOm0DI1MGUb z(l0hkeCA_hw^f)N!kVx8K`q`kEU;IgQQwX8X1fWT%FY4o_v0JKViRN zeOLzu23%JgUH58{P!w7H8ZP_i+~0p?y?2*|*AMpF=cy)!5hd@p4nOGFu~@;art6-B z%Y6Qkp6VW_8Wv0te8JJ{Ss?1Lb*^Pz?RH;y!5t{<>FU;(865l{`0(3DGp@*9)}Fs{ z=iBj+dFo$RKS`H<{=}uCtWCk=Qub$?Zmz2<4_&RZ#Fu~C6P_P(OZl#?M_t<0N6NND zrGsg%OWfx?#HoK-wPg!T+c>rq-uZd$&BBJKa)oO@UK1YUJn9kQ-e|LBw>`ATE?7`W zC3tV)!|UuRi^@N(uNJfu;Y!`T{?(GW@0cQKH_i=^0Brl}=zxOliL)A>yAR34S&(9{ z6b~+3mtRK4Hc9i=fBjH=7}F*1==tLlTl*OT&y@8(0IYZQUs> z=MbE-9kHzn_>?VhN_Miy@62ymU?utA?p~w{#Mg+GEh??5abo(6a|jbD|7)!NZ-NiM zy0Spl0)?6FzBp^Wd(RqcV*9(|7dvC>iL9vQ5p#qObe&wC(@eY}RGt+P(Cm%9>_QNB z+i@?!eAxTMA)lgo_oXpu2T#Pk-E{TkLd?kU$sBIB3)%L=qaLF7To2?ue3HGYH@WTc z*0=1M8*tBZRp-k`etG}(VcZTP?+1?I$QB8gotwkB83oN{h9w~y9gF#%2l$$aZQn#N z8|IMG`gDb~D28OB#^AZ|JksRH25#ZOGu-6OqqmyHU$|^a>d;kNS#jz`%Nicb)i*pC zawG7i6LA#ZcFD_KwR)!Z?8LbJ74;i^TFFieRPE>cEqm_u zde6X)otKR0ttm<@cEOPtxl_fdZAzX;>Q|X$l*N!6X=TEDPVKiF6{3I3)CxcReQ@!G zEQO1~tvjVR3I$V`?Ks*)(!|k67f&M;1I};!-O}US_Ymc9A8relzxCkJI)L@;}Hu zU;5f!C;rlluA!Gphxf~@%N6v0+V5s>y6;Wr+U94xdSxXXPqK`%%+7_hG#8D9E$zvB zeIVdz|GjFKv)#dydh!eN=L>RntLSzb1h+hHtd03*rnT3Fw$@vSt#!AkuU^Lq#gXL0 z$DbLfm!&Fxhf}e0XF8Cbl!~1LNSvt3ZurMs1nlgn-7Gy_0ZYtO7DwWlMmR7)OQ-da zjl_=z`H_IXwzi%&Y1uDY+G|{xzxno+L!3(uTWUlap3FZcv1zu7fM6=3BD~fyi?)3k zW0U!+LK|T+%ygQ=HOt~GuO%)sNYKC=j$Jjsme^2bR+yC8WA13vW;C#&)Z+V*+D)5U zvkRQpj8b$DKDj)w;r^Yogs_g2E=JxQ8Mi-MIJMHsv6u405(()#A@8o6$E3XRyo)n# z%d=Y4y=c*G%?;)+cGsINZagZrpY?33_uEg72L``A(5&`(7N?hx#C0r6*<`f$TZT#2 zjWLqIrsaEwKgRT`G-k%)tooZJTeG=VHokqisWZfJx0Uyy0}c%7pN^lf%=bLC|H&@>uxC4$ET~Cq>KgGEmhrT)99QWyaHNK0dcvs+ z{WBvMk0GThTn4oB)3Qc(ofMh@sS&6Qi60T6f0{jpg2Q9MD1&`xJ_b8aNbvhlcb?Dy z$E+|+j*PX`=W|gM$nt^ahD{!}~X6;0A z4#$7yRrIlWj{4m{&CEQYN^Acuu~lVw0r0Cpj8t|ewgNT;e%gs5fE@wS>YrLXKpII|Oo0tF`gNFMV`>4i`wfN)wD>v`bl2GD!R2`VIucB%Uy8XrIdI_e1QK5^siEBC8n%tut7L+kI z$l4;@w*H#UO>=s`uYksskFE}UbmfVFh9a`HG!<6B;ifg;i4!v`;zBmVo4MuH6ZyK{ zT15r&`Epp=vi%egv8M$+a$~!mx?fyhU%n|~@1D8W z^Fx3JtgitZpg|GxRBb^}WC`p6FP_3dP-JTF>(2`SL6D#KrhYAg1$>36*b^3<$(pq( z42B{u6*$SMyRBrxRvZrEcmHtxaR)tnllZ3%?QS32AG9lfWJSGjRkGSpG1vKBaGF1P z;XUt@rSI1AYwj{RXrsO2aCuD6p#ST#c$byC1QHeQzp0D5o?uZY@3j6(rneRDX03Fw zwuvw%FL>eBLowe+g9-xHNep>gE$p&;d^bAl+9y%`rFpA9*kfL~Xx-*@I&)rdj6axv zedUE)?MF>Njz7%0`N8Q}=i6gjPG7}5UuSPvti`?g+nKlr&Em_uN7dky`myDo=mWC- zSADJAKdToUd}hZ+{=ls3eaL7I)GoyKau%}xAdfnX_-%Wv-lY4w+x5|!FtIJBOYiLB z9PPYWmuyeYDky!CTyJ|*w~lJ|?EyZGAttzXd#8ex6#KKCcaLx-Z0xPNhd*UhaWnOE zPm*(-nByzsMZ6H_X6V(^H0vS9d&%WxGA$#TLC5(EpYfS=)@LkQ@GMv7e&nOQiM&oF zPA>$vimSblwAuJDX=N32wI$JXx#XT*+&b$=-CJBvM-4p4J;sdZeygW*KtSE0(jOKi zNNp0_z5x0*9F$rhZEU&i=Hke@oktB9;XZ!0-o;pHSs|i6H?K#1O~GJx`lXe7#;wjyR0T}Ussdx$BmTRcp#{EHA;FR=#i{S<_?FqxJGGn;^ zJSaY6!b!kl8)(70h7*w$Jro67dPrpDpPph;vA>=rz#?Y}u;45K7;^_kKQjd85o`Kr z`%?v+b&kJ1;v=`)a;|FFvt@4ko7oMd@D9h5+ULmJ(+@i*)Wp3_LK(lYg{+a|M*~lgSXc= zzRE%63Gc~L;nm9=$a%V{~5qMwBFkt<5d28!Da7wL5;*5}pEQ>fk-{E{rY z>b|nWPQUbF#TD1(98KNNHhG)P$Bp(REZ6K+co4aQf3a9bbuG4~;oGkb-AvD# z4lum}lh-r&*BH^vL5kl_Mt>36|0($N%f7?x6BrB)BP?l))iDt^m;2AF&y#u-GIYR6 z2{2p8;=xP=yOuhaI;J`N{kT6EzF^#f&^*||nx2XLU~NAwEp)P5IW@U~$<7^igI%U@ zFxgrDy&ZtR;Ln0nb|aN1;8P0Wl&x?|?sVjhhyy+yY&KOK79*zpSH&TdcMv_03C@;K zBf#%40wbAVsT%>CPcy*6Ix<=W=~)L^{lGC+QPR<(V|GhT{#y^j?lU(B;j@P1(44$Ez8uEo#U(nj$ks+)dnXY@p@`+m~w zDfgv?r|kAsj8XdoPs!_66|SJH-?CidOHddSUbANlYhCvE=Y-Na@wpdt-cub|@EacjhzUdCQq` zQ?^}8VtBMeqigxDMh8RgbKGan)zm&Ze7j#XeX)&?fmW1~R8sx8(#HXHBLa2%;iVbi zM=8}uS?%U*?0Yb(%BHDi!p^}wryHE#-OovyM;BdVQyufjT$NJMzQR2qtz9}$uP|-! z&e+GdVr4~2_dBZ!ua2w;w0N+bqhzBgdn|hodwsO5$VoD}Y4q;7x%iWV7U%htM+PXG zFALw7`EKijZkE}$E*&eZ;&QYX*pV!I6;kP_FRn7PiIvekcdfj9cS3^vXZr%#17GYE zlHcw6cq;6uW8v_N=s2mD&-Hi2OE~_x*`N>_{rJ%5ubW=*BtNGvJoFWQg?HLKI2auf zm}}Cr)62#6RI;~xS)8DjT*7M$?s~H?d#_ZkXe&!E_Kxy$v9~#Gd9gTVId`&s*thuI zZLJXzt1h}Tg?SU)I!URbU*J^H59oTo;GdqjCgN1TS-;I%7M6llIXFDXJr#43#FIc= z8}px!UujOSWx4Pqc|2i3%(CwxXANGrMXU2e%QuVP*(WdKaKKPCFJ~wZeiL!%e`YMp zWc5`&^Lba%=wX_)ulOH<6$ltF)*WdgzwusTZ?Pj9x3{+yv_5S+^w4K&s)C7f^FxC zmXStrL1CV{tuHLiZ;n2n)7ZEFPUrGWQ`x#6`G%XGcOLIkU9v?r_nFV}vOT#kPN>KX zJCJSO^)A)B(pP=jrz+;rUELR4-`AXrdm*YQs6J#ORMeflY)(1t^OkUel6>{|{oUWs zcy)A82JR-nLEUT>oev*crY9%QB|I@&T$FlXqt&Mb)9aR}>v4H z-S`hr$FfvmEjU$}IKAq^;XtrLSO(CfraKr3RtWO|5(gH8`!!gRiZNm5nbIo(5U)tZ zsDmJoGMFXj0~MQOy?!Y-4g-$%{T%7Q6Rw@O@bQ#EK~l(v&*vYuE2OFGRPK+wBaxrA ze?fT>o)w2>UyLzRl^{!iih={E)3GU{p`P9{7}N-pjKz$XrW~tGIr5L60MjN}>1t@h zmKGZNR)(a%c>=67mG3;*{)_?#@Rm-w^IR#as5_7S!|d}v$DM~K54z~XBrTG*o~|x( z&;|TaDFoF)P&o15vhY{{&!1R$NY5-hem*CNEH+@Ee7`#LvkwOEljd!S70fguy!4K_iRU}@e@t!ck>vg;EOOlsq^k=O;fl1vZ&>Los5cKlNkX z933W{SSvRV%^*rJ8T|E*zv0EY{p7_WKlJ-sUM$Ds^u@fx=Z3bMr9|OOc2<)fT5(3w=4}k#%L< zUnn!?in+N(@m*i>AHJVfitBEl@8!sPZ7Fc!(5a+zNpJPnEHj(;c1Qf8TzBY@0l)Y= z&G;0`?R`yQ56^eKzmx#c9bxPF^2Xh-a8=uKma4QI`G&tAxm#)u3-4zt}Bl;XIV~Nwug# zFc`jmf~Dm+7`Xb~j!ezD=j9G9ZK}O%ZCvOUb*t=J$C3xs0q?e+0r>Q{E03MO@Sa-X z`fR6+q=9Bjw+|cfHE*e#?w!|MO7nUf*6PY|9>1g4f88%gP{LAC;fjpKlKIEonG(xuDV!- z?;egnCMSKcDZ|x3vtRO(NE0>o(ZVL~aI&exyT;TuRr`DA8^w6J499AWcUb%G%Me+< zLnlM&$7uF4qic4DHIoO=mp(odwpRY&sScREw9k-3!|vYcXvt{48k@|#xrzJTtMM0n zx<0~vUNLL^wCfDr3Tt>YwHn%3NyV;_+bR@9#6^uas-2eZ4o-KmP4`{!$!=as;(Tx3 z;}RVQ%$i!q*Yv*pB$e=v+b}|(9cP_-LsH~{lgN&(1ulu~4kg){9zODkTuEU?*|N*e z1bXG4R^~~SgVxuD_3spV$_Ir%emBq9s#I%z@Y{-O>&lwMS7`|qb=;SonxEzZNr}(e z2(am3IJCrjh1Ol`@7(mDmXQ$fHS4F1fZtA6|Ha>^00#q{_eOrBGBK%utpL)0*QD|% zy#Kfd@UKqKpc@0=XDs3u-#pA);b@ny7cHOna%@ZZ*8wFeKX2rxlCE6E)YIi#%@|s2 z!&bI}KdOsg?mM$OzLMiYeB;Y13$4a_pRe0Rh23m}kBi>ze_PM*L-KyINbhi=zIRl& zcgv+RS3ap#_sz$jXx#QAZQpTMcmGAdROy8=XYmJ&5A+(49`D#_Em7PxRChOY#K^eH z`fOAqnb$Jdod0adTC>WnOJhs>^j4VBnaTHARacTbbbzu_MIWIXS4(Rncg9oMoS z(yA5GpNhZU*xkLz>AO+Qph#INE*?Z|$;je1#{%DK;-C#!VuG!9P2lu#Pci^Od+-ka&H|PbD8vtBxd`6HyCyPRsNRWW z(3|x+mIQXBr%&pjYt~Y37@X?>f5AuWfq&W5J4e}1Cu635LpG=Dd!RYirAy_~vc;u! zxBI!%*Xy-%M_w|xk;mVO7uo+qw|1eTbyu@%LoPpGh4tNT2az4tIa;#$J0F)q>vdal zJlCk|C7gUVRKM1I?GfnI>I93U+lSs**nt8;xfifZ{ORY5W9IX_Ttl><|*l(WhS`bSxdlqWA*AJ-WQR3w`rR$9?hyBh?<|+3eLei0E2H39ekPp ztlt0*!~EpX{2UBZfoI|y;N%wXPZ13GkHIb0z@;3G{EnCB6Egj2UDCB@#ty{#D0g2Q zX5Zw5*KfH3r`(>!06T}2auH5B2dA{dDSPoEzZBIZ`RfjGPn=K3;!Eg0hCCuN~|MbBefA#kM z&=L#-WAfk%$6ls!kF837?{?ie2ZN)o9L#!K{Ln?ENl4Rk{^Qlp?^dj|UaXKe?=a+F zakq-&t!z>2n~m;!nrkWR3wcku+11y7D?6@6nBV4QFSb$@o3-ibxp>Qr)Ad_Z^L@Su iQG2!6R}SyW$ja?#$2scuz8CUQ=z5_pfO^Rg^#1@O!5LNn literal 0 HcmV?d00001 diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/SL4/_._ b/packages/Rx-Interfaces.2.1.30214.0/lib/SL4/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/SL5/System.Reactive.Interfaces.XML b/packages/Rx-Interfaces.2.1.30214.0/lib/SL5/System.Reactive.Interfaces.XML new file mode 100644 index 000000000..44e662dc2 --- /dev/null +++ b/packages/Rx-Interfaces.2.1.30214.0/lib/SL5/System.Reactive.Interfaces.XML @@ -0,0 +1,368 @@ + + + + System.Reactive.Interfaces + + + + + Represents a push-style collection. + + + + + Subscribes an observer to the observable sequence. + + + + + Supports push-style iteration over an observable sequence. + + + + + Notifies the observer of a new element in the sequence. + + Next element in the sequence. + + + + Notifies the observer that an exception has occurred. + + The error that has occurred. + + + + Notifies the observer of the end of the sequence. + + + + + The System.Reactive namespace contains interfaces and classes used throughout the Reactive Extensions library. + + + + + The System.Reactive.Concurrency namespace contains interfaces and classes that provide the scheduler infrastructure used by Reactive Extensions to construct and + process event streams. Schedulers are used to parameterize the concurrency introduced by query operators, provide means to virtualize time, to process historical data, + and to write unit tests for functionality built using Reactive Extensions constructs. + + + + + The System.Reactive.Disposables namespace contains interfaces and classes that provide a compositional set of constructs used to deal with resource and subscription + management in Reactive Extensions. Those types are used extensively within the implementation of Reactive Extensions and are useful when writing custom query operators or + schedulers. + + + + + The System.Reactive.Linq namespace contains interfaces and classes that support expressing queries over observable sequences, using Language Integrated Query (LINQ). + Query operators are made available as extension methods for IObservable<T> and IQbservable<T> defined on the Observable and Qbservable classes, respectively. + + + + + The System.Reactive.Subjects namespace contains interfaces and classes to represent subjects, which are objects implementing both IObservable<T> and IObserver<T>. + Subjects are often used as sources of events, allowing one party to raise events and allowing another party to write queries over the event stream. Because of their ability to + have multiple registered observers, subjects are also used as a facility to provide multicast behavior for event streams in queries. + + + + + Scheduler with support for running periodic tasks. + This type of scheduler can be used to run timers more efficiently instead of using recursive scheduling. + + + + + Schedules a periodic piece of work. + + 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). + + + + Provider for IStopwatch objects. + + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Represents a work item that has been scheduled. + + Absolute time representation type. + + + + Invokes the work item. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Represents an object that schedules units of work. + + + + + Schedules an action to be executed. + + 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). + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + + + + Gets the scheduler's notion of current time. + + + + + Scheduler with support for starting long-running tasks. + This type of scheduler can be used to run loops more efficiently instead of using recursive scheduling. + + + + + Schedules a long-running piece of work. + + 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). + + Notes to implementers + The returned disposable object should not prevent the work from starting, but only set the cancellation flag passed to the specified action. + + + + + Abstraction for a stopwatch to compute time relative to a starting point. + + + + + Gets the time elapsed since the stopwatch object was obtained. + + + + + Disposable resource with dipsosal state tracking. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + + The type of the sender that raised the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Represents a data stream signaling its elements by means of an event. + + The type of the event data generated by the event. + + + + Event signaling the next element in the data stream. + + + + + Represents a data stream signaling its elements by means of an event. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Event signaling the next element in the data stream. + + + + + Provides a mechanism for receiving push-based notifications and returning a response. + + + The type of the elements received by the observer. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the result returned from the observer's notification handlers. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Notifies the observer of a new element in the sequence. + + The new element in the sequence. + Result returned upon observation of a new element. + + + + Notifies the observer that an exception has occurred. + + The exception that occurred. + Result returned upon observation of an error. + + + + Notifies the observer of the end of the sequence. + + Result returned upon observation of the sequence completion. + + + + Represents an observable sequence of elements that have a common key. + + + The type of the key shared by all elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the common key. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is known. + + + The type of the data in the data source. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is not specified. + + + + + Gets the type of the element(s) that are returned when the expression tree associated with this instance of IQbservable is executed. + + + + + Gets the expression tree that is associated with the instance of IQbservable. + + + + + Gets the query provider that is associated with this data source. + + + + + Defines methods to create and execute queries that are described by an IQbservable object. + + + + + Constructs an IQbservable>TResult< object that can evaluate the query represented by a specified expression tree. + + The type of the elements of the System.Reactive.Linq.IQbservable<T> that is returned. + Expression tree representing the query. + IQbservable object that can evaluate the given query expression. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + + The type of the elements in the sequence. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Represents an object that is both an observable sequence as well as an observer. + + The type of the elements processed by the subject. + + + + Represents an object that is both an observable sequence as well as an observer. + + + The type of the elements received by the subject. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements produced by the subject. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/SL5/System.Reactive.Interfaces.dll b/packages/Rx-Interfaces.2.1.30214.0/lib/SL5/System.Reactive.Interfaces.dll new file mode 100644 index 0000000000000000000000000000000000000000..80df8992c774dfce1169a2ef6723673c321309dc GIT binary patch literal 24152 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 ad*l0`&Ko7iq+R*k=e8|Nyw@x4;r{`#5D$<5 literal 0 HcmV?d00001 diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/WP8/System.Reactive.Interfaces.XML b/packages/Rx-Interfaces.2.1.30214.0/lib/WP8/System.Reactive.Interfaces.XML new file mode 100644 index 000000000..30ff445df --- /dev/null +++ b/packages/Rx-Interfaces.2.1.30214.0/lib/WP8/System.Reactive.Interfaces.XML @@ -0,0 +1,336 @@ + + + + System.Reactive.Interfaces + + + + + The System.Reactive namespace contains interfaces and classes used throughout the Reactive Extensions library. + + + + + The System.Reactive.Concurrency namespace contains interfaces and classes that provide the scheduler infrastructure used by Reactive Extensions to construct and + process event streams. Schedulers are used to parameterize the concurrency introduced by query operators, provide means to virtualize time, to process historical data, + and to write unit tests for functionality built using Reactive Extensions constructs. + + + + + The System.Reactive.Disposables namespace contains interfaces and classes that provide a compositional set of constructs used to deal with resource and subscription + management in Reactive Extensions. Those types are used extensively within the implementation of Reactive Extensions and are useful when writing custom query operators or + schedulers. + + + + + The System.Reactive.Linq namespace contains interfaces and classes that support expressing queries over observable sequences, using Language Integrated Query (LINQ). + Query operators are made available as extension methods for IObservable<T> and IQbservable<T> defined on the Observable and Qbservable classes, respectively. + + + + + The System.Reactive.Subjects namespace contains interfaces and classes to represent subjects, which are objects implementing both IObservable<T> and IObserver<T>. + Subjects are often used as sources of events, allowing one party to raise events and allowing another party to write queries over the event stream. Because of their ability to + have multiple registered observers, subjects are also used as a facility to provide multicast behavior for event streams in queries. + + + + + Scheduler with support for running periodic tasks. + This type of scheduler can be used to run timers more efficiently instead of using recursive scheduling. + + + + + Schedules a periodic piece of work. + + 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). + + + + Provider for IStopwatch objects. + + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Represents a work item that has been scheduled. + + Absolute time representation type. + + + + Invokes the work item. + + + + + Gets the absolute time at which the item is due for invocation. + + + + + Represents an object that schedules units of work. + + + + + Schedules an action to be executed. + + 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). + + + + Schedules an action to be executed after dueTime. + + 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). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + + + + Gets the scheduler's notion of current time. + + + + + Scheduler with support for starting long-running tasks. + This type of scheduler can be used to run loops more efficiently instead of using recursive scheduling. + + + + + Schedules a long-running piece of work. + + 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). + + Notes to implementers + The returned disposable object should not prevent the work from starting, but only set the cancellation flag passed to the specified action. + + + + + Abstraction for a stopwatch to compute time relative to a starting point. + + + + + Gets the time elapsed since the stopwatch object was obtained. + + + + + Disposable resource with dipsosal state tracking. + + + + + Gets a value that indicates whether the object is disposed. + + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + + The type of the sender that raised the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Represents a data stream signaling its elements by means of an event. + + The type of the event data generated by the event. + + + + Event signaling the next element in the data stream. + + + + + Represents a data stream signaling its elements by means of an event. + + + The type of the event data generated by the event. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Event signaling the next element in the data stream. + + + + + Provides a mechanism for receiving push-based notifications and returning a response. + + + The type of the elements received by the observer. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the result returned from the observer's notification handlers. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Notifies the observer of a new element in the sequence. + + The new element in the sequence. + Result returned upon observation of a new element. + + + + Notifies the observer that an exception has occurred. + + The exception that occurred. + Result returned upon observation of an error. + + + + Notifies the observer of the end of the sequence. + + Result returned upon observation of the sequence completion. + + + + Represents an observable sequence of elements that have a common key. + + + The type of the key shared by all elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements in the group. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Gets the common key. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is known. + + + The type of the data in the data source. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Provides functionality to evaluate queries against a specific data source wherein the type of the data is not specified. + + + + + Gets the type of the element(s) that are returned when the expression tree associated with this instance of IQbservable is executed. + + + + + Gets the expression tree that is associated with the instance of IQbservable. + + + + + Gets the query provider that is associated with this data source. + + + + + Defines methods to create and execute queries that are described by an IQbservable object. + + + + + Constructs an IQbservable>TResult< object that can evaluate the query represented by a specified expression tree. + + The type of the elements of the System.Reactive.Linq.IQbservable<T> that is returned. + Expression tree representing the query. + IQbservable object that can evaluate the given query expression. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + + The type of the elements in the sequence. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Represents an object that is both an observable sequence as well as an observer. + + The type of the elements processed by the subject. + + + + Represents an object that is both an observable sequence as well as an observer. + + + The type of the elements received by the subject. + This type parameter is contravariant. That is, you can use either the type you specified or any type that is less derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + The type of the elements produced by the subject. + This type parameter is covariant. That is, you can use either the type you specified or any type that is more derived. For more information about covariance and contravariance, see Covariance and Contravariance in Generics. + + + + diff --git a/packages/Rx-Interfaces.2.1.30214.0/lib/WP8/System.Reactive.Interfaces.dll b/packages/Rx-Interfaces.2.1.30214.0/lib/WP8/System.Reactive.Interfaces.dll new file mode 100644 index 0000000000000000000000000000000000000000..808334b428e9b59a081031942195089e8345f027 GIT binary patch literal 24136 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 B^pXGo literal 0 HcmV?d00001 diff --git a/packages/Rx-Linq.2.1.30214.0/Rx-Linq.2.1.30214.0.nupkg b/packages/Rx-Linq.2.1.30214.0/Rx-Linq.2.1.30214.0.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..04181568f8306b9b00e25e5b396a9d00a0f6bb05 GIT binary patch literal 1806118 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 z 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 z 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�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

q44& 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 z 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�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

&?l&j|0bbX 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

vwx;>(8^9qb*33#agbS+K*fJ*6fVF9G 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

}NRl7OJ3t)7E6%h3;~%E!Q&7rC?JEPoU9W<>K;o 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

*50?Hrhmv!$0tq7;&v09 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�W8N{mhru*-@y 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

1Phaou*?=2!DoB_*cjHw zp<5C?8f?inrc_uH5Qs(r@xysOt^KvGZLbC+I5s> z%OJ-w9_a@)TE41$LgeMsI3Ha+awif%xeQl)dN8$I06XL5F~9 z71LmsIPz3w(Z^!rcJvIMIwBEnuDfoYI{Y0-%>nC*TbE)~8jRZfC=3q>jR@{MMYLb( zL-B!mGvYkd5ts$l5yXDcQPJv;=RH9U%B?z&ZPAEOC!l$2R3#Tb0aZRZ}Tiu!rq=bJ*3nZH>TEoYs{{0;U-+GL#u&L zU+B72CopWAZgn%yK3dkwjcR>$+>rC^Y+lZlA3o@QNW5Kp#!vH&bhx`xvS;r;Rjg~8 zr{Kce;`altQW@u&(|RznRi4Q6?N%#^WKTBQ7O(RJ{%-TjgR|Ka{{W1#G$zYOY) zOB~{x5bWdIH)4wLbeo~7sC2vK!hLLMQ3ydI$eTCf94i~F=WRZ6n-=9Aj!Dl9Bf7-W z-9iocgTitHx+D*nQ&M)?t!1_v>@FBR8Pm{Z==GzqI_wyI_d7ls8O_gN3iRYq-jcib zJuzO@Y9(8_M5`Q77C-1sTzsqJ+{pc{v{;pblflqh0J$4oW3Q?+eg~T@^h=@Pl%WHa znuSD!#|GEIHpWG?WmC5cEb1O%dg~rS7ep0znYo>7QX-eeJ*XI0q?^U`;fAz7yC9MfdjOwQyE5W;x zlq-^yZsxh;uP2F(AvY|<(8k^DEG&*EW_%A!K|*+-DtDF&#CH<>)(d>$)EsZIS2RAC zo*nG^C~Ek`UB#No_=LJLqh86`;^9YjUs2-;dwX!BFm$R11BuM&+mgqTG~D{x8s%Qw zOPuR4_-cNUBg5MDEu~Q*HXCK8VX|Nd%yAtqEU5csgT7i6^1%SCb#C|iWh;Z9!UvD6 z+IO=ohew=v5evIiu_f9`A*m1=W|;*a7p2G|tZC^#%q)mpa!nGW=8W(9{nZg&+%NDf-3Ui9Q*U#N^r3gFJ%z zxnc@-idfvDr@@A{wZZ0$wq1s$@NK9a$9cAN97GCgc0RECenp+CC1D3jjI1!rV?hPV zYhAAJ+>jVVZ669kd_gj#Ee#0C~NbOIw{BHv_`X(=sRiD#V?6dOd@)CZs~lUW1c8^T;aJ@_C>)0 zv8<61WATT@_v-~@E#IL=HI;X?D_$s|u2<;vqqkv2&XorbS)cTA&Jv_cJ+y9%<%@G1 z2co%FWPD(-`O|pYk>v4E;Q%o$9E~j{HIgMzm#B3_4XN}b&H8Erai0%#1E4#*F`_@B z)2U5E+gs}_CJ$^fe(tUIm|SEB^kjm=78owv{LSaMAGCF9nh<IfN%5QQz!!sZZJ#YRU?c(GYA75?4H(iGO z2lhi)oL!T~j!jF>}TZ}v{){~ziONv&;p=yhD8R&eXCg${DM(OyEWB`7JKy?4 zw&XR8o8&^Sp?XSgmti2}@(J77zrzr> zFPX0(>EUPd>TxY&jQFAp$wj1ovJUb){T1Kca)Oy&0W(G<#D+*g@5w(%GE6EO@s2;( zko`W^7(q@>a$v?InTD+91E-&@T~y`J;g*VAF%4SUry4-)8B%Q=vXNB zh!^BB0>j2=>7#_x%y-#&NWG)1J^i(%O%_xQbol6xZa>nJn zDp7vgtq0Dccuu_266GHZwtnsL-kfu|Dw^=raya%7h#A%JWo&pGzBjFq1L;{AcJ<@a zD|7#(g*Sc?*#O8i#!V~Pxx-V&F*Ae*Lz8{7ukVFyHERQAR*w$ln_L3^JoDU z^Ye&8c-R3eY-ueAcraD30MqIusJ>V@wKuDQrU82s5sXD}#LBy&9-V^mJbZ0Oi-VBa zaf26OS~;(^Kn!U0&Y%=I6|Jn3M29(p(GhVz##J6vmglV40K@gX>v|L`eCSv&V?$hv zJFM_HJRTlmm%FyyS*4;@x2Lh4BJh5RtWv8$xKCgv{%jJ#uPtMyjfqlOM`{bOpigFVj zfbSFc8y0-4MybVd9py?CHH%ne}lUyK{3ujXR zv$XqcVjaV-e%)O+(#wl9I%Dc%TOcspIZ|!0V>jb%y4$+_K!~`-W@*6LCglH-qfHr)wLqp&9XfzY@4hNf4*Eeb5pLJM0>(wI`lQ5nl0PyoZ?n+)~x~ z!{J_P=X7(tmXpRYyb8b8t$l6hba3PwZkcr;#i+>j9;fYxq?mXD>^9Y+_C{uty)QUC zR9je#?jbjIdg0K}M+&ghk4w8o!5r=Zo1k9M$N2f~0lkF1_AthyH$)F}6lO>SAvG-c ztHFv;D?gEa9d8i@hOC!WM}DGE9!T7+r~y}|;~o4$Zb`EV9V7gPMqt*BjvDaNu3uE> zAGX^xX%-zfFl{e$*5|PpFOOTh-7c!L&zzKNW$b@dXSQ_S>SiD9@?jlyaLo*RGKluy zH}IA4yNs>}mzh?mNj!We>vo7!HmLp{Ty(eQy5KxLFU2kMs|C1{ARMg9*3!5EU#8vAsUD0?=_nl~GNyM)Rys-ut5pLm(B}-4_L!&@@mzq0GRW@%#PYQqM|S zb#FZo-s>RIHE6KriW8?2hhcA(Sh-*r_viReH{wiAYl5_t1m`6)U-(n^M?xpnF7kC+ z9;bM^w0unG__y*05q4qd3BcZqL?XJkJW=z!>vs23G~QClWPjpDsm#1%^=aF~o-g%I z-B^$yqJ)1J{)8mU5#cW0Y`x=E046I`@GX$bezYh zu>S)praGo6E&fT@Aqo)NEm@}jqjNH1VIPeA4}IWqqA)xOaB zP3Pfexz1+hHIpROV|(2snILQUEQV?#iOj>afW*Zwcl_x%+SIddaVNm&l^qL3<{5>w zkUHLlOs%f!(DbF`1dz0^T#{jEh>FXm#_Co;GTH)1bC|sul;p0LnQ$Vj1q+CFHw%?~{j%m?o z3GD2ia$u-_UKRo)G4~Y(MW?wCo6*G1oPmXy@)gOegUf=mDe%-XiNVI=i z4}NEkBm~a`aT@>H1=TPX)X@gP5#ih5+i)MlB5E<=@I&;Xy%N{P-Nz5>sBcL?bSll3 zeoUf3GOKn@N}+7PcSs~7Ui7OT6DYE5y46{h?LzPN2M`Aby!@tOe&MV&R~uF)EL`u;skgUdBtB;uezg zu}yJnMUqmtekDoabueC+vzh3~>5^iA8R{LzdS4t27NM`(rMrZn5 z>)lvS0j3pmf^Se*!<_7|;IBgv4)dV&!Y=sM=RtZoESK~nm;^y@KY(#Fz1Bx0lUH^40xxm-U}`Zcp?yd#>LYC$ zMW0VN680}zojI1^7x|J{K-iIhs3$l4MD^>#`Q9zEKpI~(b<|c?1G>OelV|*82tb5e`;ignAhCaV<_b^{{>XEe?bJ4KS(-dCLX>~v^TcVn2@jnm{Mrzu<;w+;hi9&(aW!x_~g7I7_!Rg?%zJso9N=3 zK*Jsy>MaO|66bSCQwFy=b$qoPR=}fYX0D2PLgFvm<}8 zrQHbcr;{f*cP~nvX&#s=3>?=Nuh2f;;GrsoAyVOo?i3lCigf-ar3dtN$9}hG*Bz9~ zZ4%W$s>8;}9Ot)&AZ*nJ@m+YO9zff`1YVjJ{hA0AYZXS^*IW%0K_RI7z2oS~21|1e zKrW%-Go{sjUdkZ5(IWchdmLJD-tITJ9Hex z8ME*&n){Acy;B9cV|`yf)1&D3^Mm*cf>8VBQf_D(B25HOZp_#%z>C&*J#onN!&u_S zNS#=B_)~yE&v#)5*tB&`FGu=)t8PR6<%ek(g>fCgtuk11Osr*jcC#37tMPGVeITwN zjLl>Muvy^=kiA7=!k#n>i+4=xZRaw=96O-L=R; zM1Ghxi)l)~ z`fa*CfWkb^RtY3n)XKN|jjR0B*p))xep(Hj@^M$kmB72nx+VAuzyXJs$lUhyu3|bh zHQi@2I|Z+O_NapB;S8i^LGmhiYY^{dL+UVKM`H5b`jd-gsBL(r}G4h>U-oYNzH3xjx1X13i zQ;-*cdvSqj5EskVj!E=%Img%h8#5&h9~$6Z8ovlHKV`@NgjMn@p21AXnKy+seBCua zO(u_krT)x$BtNbU0VsgYDTG zI5b!}uRmQA9yG)pCPp@EMd=(3dkSz9N<#F%V3I_BmisAw+Jn*ebRr!m!&vE&#J?aF zq?$Uq03BD>tzV+d76}!_+0C>0F_?o>@YfY^R58N2TYt_X7+>eDS*l>(#RTZu9Ei6kY=wOt9TW zd;%*K{B~Pjhkibpf);+)>)BvbdJugam%Ps_8bWfc77 zaeWQ;=JK<_eq8sdHwfzlT#4Ewuj6rzR42f0C*tM(=@?hVHa0e z$qcah$Mk)RPb0MR>&0_!gE1J1_jyHlckzbq>UlZYyD!VLul3qG(*t*p?jPZ6`$6Y_rtH_tLw%^xyyFn01pZo-*AVW1?=|^aDfBC1F^9*W>k@7V>Dne zAS(O_LY0sHx3s_ff`j~qf&F9eZzC04EnqV1g+(2N#<$modP|jERkno7F*V^Qv2by5;9+ERaCNd_uy-%|k z0&uc*{+9xOr2HeNhqL8Ba=E*^Gq|(<0nEb0#LTEEC#zy&0kAcqx3qJ1F|soO{2l)v z63%}lJ2L>yWCvtvX76Nc4 z@+6YAG)}sHjz5Y=Cx7>Vx)PaA7p}?Q3(izHh zE*r2K{r;i>tCEhWy&cd8E(WTe4ghC8hTnnyZ))cMy)yiP_qVwIe~vqozj2~>`OOI! zY+?X2BUc-je})S`i4(xanFJVce~|yJi=V{E!NJDTd_t`?sRN3jCjn8vLh%e`^Q- zjr6~<=wBM$f7q1qj~D<3ASf6;$Uj^2Sx7&yb5IbF-(R@DwEQ3-2ERSa_}fd)e-r%Y z(PYna$ejilxAKr6Ac%hwWCrg2dp&0Oo7?^>8~Uhc)@K9`BIyMSLh>isA_$N_j!W_Y z7d9qF6;EdufGxv+Rau7LO#=hamw(06WC}XMZv_D%#zp!IUauMW|Aq&2@L%z`=_Pm` zEP?zI{>qONAL1W)?Ehze1Zgl2(rq9h5VU{g7a0!yzv2Ba{3!lpKSse1|Ahx^{{d|O z8OJ|khE~A+Uoig{p1gnNX$1cVrlP%*%kM)3{cne}le36uSlTJ8{%uW>>pwE^pA}_J zApOUR{zZw*W0#OK=)ph?!Jt4G|5PHaVB|j(0ee*Rz(SbXyE`jd*xLa(ng7qF0I>}0 z8At&E@koaK3%E`L>i-k?zhE8-dq`akzA{=0hDFx-FD(@>Owg!-Kg4fw$Uu02HH0=ND@ D5HOZU literal 0 HcmV?d00001 diff --git a/packages/Rx-Linq.2.1.30214.0/Rx-Linq.2.1.30214.0.nuspec b/packages/Rx-Linq.2.1.30214.0/Rx-Linq.2.1.30214.0.nuspec new file mode 100644 index 000000000..e1e829a3a --- /dev/null +++ b/packages/Rx-Linq.2.1.30214.0/Rx-Linq.2.1.30214.0.nuspec @@ -0,0 +1,26 @@ + + + + Rx-Linq + 2.1.30214.0 + Reactive Extensions - Query Library + Microsoft Corporation + Microsoft Corporation + http://go.microsoft.com/fwlink/?LinkID=261272 + http://go.microsoft.com/fwlink/?LinkID=261273 + http://go.microsoft.com/fwlink/?LinkId=261274 + true + Reactive Extensions Query Library used to express complex event processing queries over observable sequences. + Microsoft Corporation © 2012 + en-us + Rx Reactive Extensions Observable LINQ Events + + + + + + + + + + \ No newline at end of file diff --git a/packages/Rx-Linq.2.1.30214.0/lib/Net40/System.Reactive.Linq.XML b/packages/Rx-Linq.2.1.30214.0/lib/Net40/System.Reactive.Linq.XML new file mode 100644 index 000000000..2ee99f58d --- /dev/null +++ b/packages/Rx-Linq.2.1.30214.0/lib/Net40/System.Reactive.Linq.XML @@ -0,0 +1,10510 @@ + + + + System.Reactive.Linq + + + + + The System.Reactive.Joins namespace contains classes used to express join patterns over observable sequences using fluent method syntax. + + + + + Provides a set of extension methods for virtual time scheduling. + + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Attribute applied to static classes providing expression tree forms of query methods, + mapping those to the corresponding methods for local query execution on the specified + target class type. + + + + + Creates a new mapping to the specified local execution query method implementation type. + + Type with query methods for local execution. + + + + Gets the type with the implementation of local query methods. + + + + + Provides a set of static methods for writing in-memory queries over observable sequences. + + + + + Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. + The loop can be quit prematurely by setting the specified cancellation token. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Cancellation token used to stop the loop. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. + The loop can be quit prematurely by setting the specified cancellation token. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Cancellation token used to stop the loop. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Uses to determine which source in to return, choosing if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Default source to select in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence on the specified scheduler if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Scheduler to generate an empty sequence on in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated after each repeated completed. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated upon the completion of an iteration through the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Concatenates the observable sequences obtained by running the for each element in the given enumerable . + + The type of the elements in the enumerable source sequence. + The type of the elements in the observable result sequence. + Enumerable source for which each element will be mapped onto an observable source that will be concatenated in the result sequence. + Function to select an observable source for each element in the . + The observable sequence obtained by concatenating the sources returned by for each element in the . + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, select the sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Sequence returned in case evaluates false. + if evaluates true; otherwise. + or or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + if evaluates true; an empty sequence otherwise. + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence generated on the specified scheduler. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Scheduler to generate an empty sequence on in case evaluates false. + if evaluates true; an empty sequence otherwise. + or or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated before each repeated is subscribed to. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated before subscription to the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the fourteenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the fourteenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Invokes the specified function asynchronously, surfacing the result through an observable sequence. + + The type of the result returned by the function. + Function to run asynchronously. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence + + The type of the result returned by the function. + Function to run asynchronously. + Scheduler to run the function on. + An observable sequence exposing the function's result value, or an exception. + or is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the asynchronous function, surfacing the result through an observable sequence. + + The type of the result returned by the asynchronous function. + Asynchronous function to run. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the asynchronous function, surfacing the result through an observable sequence. + The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information. + + The type of the result returned by the asynchronous function. + Asynchronous function to run. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + If any subscription to the resulting sequence is disposed, the CancellationToken is set. The observer associated to the disposed + subscription won't see the TaskCanceledException, but other observers will. You can protect against this using the Catch operator. + Be careful when handing out the resulting sequence because of this behavior. The most common use is to have a single subscription + to the resulting sequence, which controls the CancellationToken state. Alternatively, you can control subscription behavior using + multicast operators. + + + + + + + Invokes the action asynchronously, surfacing the result through an observable sequence. + + Action to run asynchronously. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the action asynchronously on the specified scheduler, surfacing the result through an observable sequence. + + Action to run asynchronously. + Scheduler to run the action on. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + or is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the asynchronous action, surfacing the result through an observable sequence. + + Asynchronous action to run. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the asynchronous action, surfacing the result through an observable sequence. + The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information. + + Asynchronous action to run. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + If any subscription to the resulting sequence is disposed, the CancellationToken is set. The observer associated to the disposed + subscription won't see the TaskCanceledException, but other observers will. You can protect against this using the Catch operator. + Be careful when handing out the resulting sequence because of this behavior. The most common use is to have a single subscription + to the resulting sequence, which controls the CancellationToken state. Alternatively, you can control subscription behavior using + multicast operators. + + + + + + + Converts to asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. + + The type of the result returned by the asynchronous function. + Asynchronous function to convert. + An observable sequence exposing the result of invoking the function, or an exception. + is null. + + + + Converts to asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. + The CancellationToken passed to the asynchronous function is tied to the observable sequence's subscription that triggered the function's invocation and can be used for best-effort cancellation. + + The type of the result returned by the asynchronous function. + Asynchronous function to convert. + An observable sequence exposing the result of invoking the function, or an exception. + is null. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous function will be signaled. + + + + Converts to asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. + + Asynchronous action to convert. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + + Converts to asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. + The CancellationToken passed to the asynchronous action is tied to the observable sequence's subscription that triggered the action's invocation and can be used for best-effort cancellation. + + Asynchronous action to convert. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous function will be signaled. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the sixteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the sixteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + The type of the sixteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + The type of the sixteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value, + and the specified result selector function is used to select the result value. + + The type of the elements in the source sequence. + The type of the accumulator value. + The type of the resulting value. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + A function to transform the final accumulator value into the result value. + An observable sequence containing a single element with the final accumulator value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to aggregate over. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether all elements of an observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains any elements. + + The type of the elements in the source sequence. + An observable sequence to check for non-emptiness. + An observable sequence containing a single element determining whether the source sequence contains any elements. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether any element of an observable sequence satisfies a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether any elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + (Asynchronous) The sum of the elements in the source sequence is larger than . + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using the default equality comparer. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using a specified System.Collections.Generic.IEqualityComparer<T>. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An equality comparer to compare elements. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the element at a specified index in a sequence. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence. + is null. + is less than zero. + (Asynchronous) is greater than or equal to the number of elements in the source sequence. + + + + Returns the element at a specified index in a sequence or a default value if the index is out of range. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence, or a default value if the index is outside the bounds of the source sequence. + is null. + is less than zero. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Determines whether an observable sequence is empty. + + The type of the elements in the source sequence. + An observable sequence to check for emptiness. + An observable sequence containing a single element determining whether the source sequence is empty. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + An observable sequence containing a single element with the maximum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + An observable sequence containing a single element with the minimum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the only element of an observable sequence, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence. + is null. + (Asynchronous) The source sequence contains more than one element. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence, or a default value if no such element exists. + is null. + (Asynchronous) The source sequence contains more than one element. + + + + Returns the only element of an observable sequence that matches the predicate, or a default value if no such element exists; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + (Asynchronous) The sequence contains more than one element that satisfies the condition in the predicate. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates an array from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get an array of elements for. + An observable sequence containing a single element with an array containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a list from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get a list of elements for. + An observable sequence containing a single element with a list containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Multicasts the source sequence notifications through the specified subject to the resulting connectable observable. Upon connection of the + connectable observable, the subject is subscribed to the source exactly one, and messages are forwarded to the observers registered with + the connectable observable. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be pushed into the specified subject. + Subject to push source elements into. + A connectable observable sequence that upon connection causes the source sequence to push results into the specified subject. + or is null. + + + + Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each + subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's + invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements produced by the intermediate subject. + The type of the elements in the result sequence. + Source sequence which will be multicasted in the specified selector function. + Factory function to create an intermediate subject through which the source sequence's elements will be multicast to the selector function. + Selector function which can use the multicasted source sequence subject to the policies enforced by the created subject. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Initial value received by observers upon subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + Initial value received by observers upon subscription. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will only receive the last notification of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will only receive the last notification of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + + The type of the elements in the source sequence. + Connectable observable sequence. + An observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all the notifications of the source. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + Subscribers will receive all the notifications of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Produces an enumerable sequence of consecutive (possibly empty) chunks of the source sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns consecutive (possibly empty) chunks upon each iteration. + is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create a new collector object. + Merges a sequence element with the current collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create the initial collector object. + Merges a sequence element with the current collector. + Factory to replace the current collector by a new collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or or is null. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Invokes an action for each element in the observable sequence, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Returns an enumerator that enumerates all values of the observable sequence. + + The type of the elements in the source sequence. + An observable sequence to get an enumerator for. + The enumerator that can be used to enumerate over the elements in the observable sequence. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Returns an enumerable sequence whose enumeration returns the latest observed element in the source observable sequence. + Enumerators on the resulting sequence will never produce the same element repeatedly, and will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns the last sampled element upon each iteration and subsequently blocks until the next element in the observable source sequence becomes available. + + + + Returns an enumerable sequence whose enumeration returns the most recently observed element in the source observable sequence, using the specified initial value in case no element has been sampled yet. + Enumerators on the resulting sequence never block and can produce the same element repeatedly. + + The type of the elements in the source sequence. + Source observable sequence. + Initial value that will be yielded by the enumerable sequence if no element has been sampled yet. + The enumerable sequence that returns the last sampled element upon each iteration. + is null. + + + + Returns an enumerable sequence whose enumeration blocks until the next element in the source observable sequence becomes available. + Enumerators on the resulting sequence will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that blocks upon each iteration until the next element in the observable source sequence becomes available. + is null. + + + + Returns the only element of an observable sequence, and throws an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence. + is null. + The source sequence contains more than one element. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and throws an exception if there is not exactly one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method throws an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence, or a default value if no such element exists. + is null. + The source sequence contains more than one element. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists; this method throws an exception if there is more than one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + The sequence contains more than one element that satisfies the condition in the predicate. + + + + + Waits for the observable sequence to complete and returns the last element of the sequence. + If the sequence terminates with an OnError notification, the exception is throw. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + This only invokes observer callbacks on a scheduler. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a scheduler, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + This only invokes observer callbacks on a synchronization context. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a synchronization context, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified scheduler. In order to invoke observer + callbacks on a scheduler, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified synchronization context. In order to invoke observer + callbacks on a synchronization context, use . + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently. + This overload is useful to "fix" an observable sequence that exhibits concurrent callbacks on individual observers, which is invalid behavior for the query processor. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + It's invalid behavior - according to the observer grammar - for a sequence to exhibit concurrent callbacks on a given observer. + This operator can be used to "fix" a source that doesn't conform to this rule. + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently, using the specified gate object. + This overload is useful when writing n-ary query operators, in order to prevent concurrent callbacks from different sources by synchronizing on a common gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Subscribes an observer to an enumerable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Disposable object that can be used to unsubscribe the observer from the enumerable + or is null. + + + + Subscribes an observer to an enumerable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Scheduler to perform the enumeration on. + Disposable object that can be used to unsubscribe the observer from the enumerable + or or is null. + + + + Converts an observable sequence to an enumerable sequence. + + The type of the elements in the source sequence. + An observable sequence to convert to an enumerable sequence. + The enumerable sequence containing the elements in the observable sequence. + is null. + + + + Exposes an observable sequence as an object with an Action-based .NET event. + + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with an Action<TSource>-based .NET event. + + The type of the elements in the source sequence. + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with a .NET event, conforming to the standard .NET event pattern. + + The type of the event data generated by the event. + Observable source sequence. + The event source object. + is null. + + + + Converts an enumerable sequence to an observable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + The observable sequence whose elements are pulled from the given enumerable sequence. + is null. + + + + Converts an enumerable sequence to an observable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + Scheduler to run the enumeration of the input sequence on. + The observable sequence whose elements are pulled from the given enumerable sequence. + or is null. + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to produce elements. + The observable sequence surfacing the elements produced by the asynchronous method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to produce elements. + The observable sequence surfacing the elements produced by the asynchronous method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Observable factory function to invoke for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger an invocation of the given observable factory function. + is null. + + + + Returns an observable sequence that starts the specified asynchronous factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Asynchronous factory function to start for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger the given asynchronous observable factory function to be started. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Returns an observable sequence that starts the specified cancellable asynchronous factory function whenever a new observer subscribes. + The CancellationToken passed to the asynchronous factory function is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Asynchronous factory function to start for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger the given asynchronous observable factory function to be started. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous observable factory function will be signaled. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence with no elements. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + An observable sequence with no elements. + is null. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + The generated sequence. + or or is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements, using the specified scheduler to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Scheduler on which to run the generator loop. + The generated sequence. + or or or is null. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence whose observers will never get called. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence whose observers will never get called. + + + + Generates an observable sequence of integral numbers within a specified range. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + + + + Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to send out observer messages. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + Scheduler to run the generator loop on. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + is null. + + + + Generates an observable sequence that repeats the given element infinitely. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + An observable sequence that repeats the given element infinitely. + + + + Generates an observable sequence that repeats the given element infinitely, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element infinitely. + is null. + + + + Generates an observable sequence that repeats the given element the specified number of times. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + + + + Generates an observable sequence that repeats the given element the specified number of times, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + is null. + + + + Returns an observable sequence that contains a single element. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + An observable sequence containing the single specified element. + + + + Returns an observable sequence that contains a single element, using the specified scheduler to send out observer messages. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + Scheduler to send the single element on. + An observable sequence containing the single specified element. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Factory function to obtain a resource object. + Factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. The resource is obtained and used through asynchronous methods. + The CancellationToken passed to the asynchronous methods is tied to the returned disposable subscription, allowing best-effort cancellation at any stage of the resource acquisition or usage. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Asynchronous factory function to obtain a resource object. + Asynchronous factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous resource factory and observable factory functions will be signaled. + + + + Creates a pattern that matches when both observable sequences have an available element. + + The type of the elements in the left sequence. + The type of the elements in the right sequence. + Observable sequence to match with the right sequence. + Observable sequence to match with the left sequence. + Pattern object that matches when both observable sequences have an available element. + or is null. + + + + Matches when the observable sequence has an available element and projects the element by invoking the selector function. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, returned by the selector function. + Observable sequence to apply the selector on. + Selector that will be invoked for elements in the source sequence. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + or is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results from matching several patterns. + is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results form matching several patterns. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that surfaces either of the given sequences, whichever reacted first. + or is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + A function invoked to define the boundaries of the produced buffers. A new buffer is started when the previous one is closed. + An observable sequence of buffers. + or is null. + + + + Projects each element of an observable sequence into zero or more buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequence indicating buffer opening events, also passed to the closing selector to obtain a sequence of buffer closing events. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + Observable sequence whose elements denote the creation of new buffers. + A function invoked to define the closing of each produced buffer. + An observable sequence of buffers. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer boundary events. + Source sequence to produce buffers over. + Sequence of buffer boundary markers. The current buffer is closed and a new buffer is opened upon receiving a boundary marker. + An observable sequence of buffers. + or is null. + + + + Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler. + + The type of the elements in the source sequence and sequences returned by the exception handler function. + The type of the exception to catch and handle. Needs to derive from . + Source sequence. + Exception handler function, producing another observable sequence. + An observable sequence containing the source sequence's elements, followed by the elements produced by the handler's resulting observable sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source sequence and handler sequence. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results when an error occurred in the first sequence. + An observable sequence containing the first sequence's elements, followed by the elements of the second sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Merges two observable sequences into one observable sequence by using the selector function whenever one of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke whenever either of the sources produces an element. + An observable sequence containing the result of combining elements of both sources using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Sixteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke whenever any of the sources produces an element. For efficiency, the input list is reused after the selector returns. Either aggregate or copy the values during the function call. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful termination of the first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that contains the elements of the first sequence, followed by those of the second the sequence. + or is null. + + + + Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all inner observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + An observable sequence that contains the elements of each observed inner sequence, in sequential order. + is null. + + + + Concatenates all task results, as long as the previous task terminated successfully. + + The type of the results produced by the tasks. + Observable sequence of tasks. + An observable sequence that contains the results of each task, in sequential order. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a concatenation operation using . + + + + Merges elements from all inner observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that merges the elements of the inner sequences. + is null. + + + + Merges results from all source tasks into a single observable sequence. + + The type of the results produced by the source tasks. + Observable sequence of tasks. + The observable sequence that merges the results of the source tasks. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a merge operation using . + + + + Merges elements from all inner observable sequences into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + Maximum number of inner observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the inner sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the observable sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences, and using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + is less than or equal to zero. + + + + Merges elements from two observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + The observable sequence that merges the elements of the given sequences. + or is null. + + + + Merges elements from two observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + Scheduler used to introduce concurrency for making subscriptions to the given sequences. + The observable sequence that merges the elements of the given sequences. + or or is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful or exceptional termination of the first. + + The type of the elements in the source sequences. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results after the first sequence terminates. + An observable sequence that concatenates the first and second sequence, even if the first sequence terminates exceptionally. + or is null. + + + + Concatenates all of the specified observable sequences, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Returns the elements from the source observable sequence only after the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of skip behavior. + Source sequence to propagate elements for. + Observable sequence that triggers propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation. + or is null. + + + + Switches between the inner observable sequences such that the resulting sequence always produces elements from the most recently received inner observable sequence. + Each time a new inner observable sequence is received, the previous inner observable sequence is unsubscribed from. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received. + is null. + + + + Switches between the tasks such that the resulting sequence always produces results from the most recently received task. + Each time a new task is received, the previous task's result is ignored. + + The type of the results produced by the source tasks. + Observable sequence of tasks. + The observable sequence that at any point in time produces the result of the most recent task that has been received. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a switch operation using . + + + + Returns the elements from the source observable sequence until the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of take behavior. + Source sequence to propagate elements for. + Observable sequence that terminates propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + A function invoked to define the boundaries of the produced windows. A new window is started when the previous one is closed. + An observable sequence of windows. + or is null. + + + + Projects each element of an observable sequence into zero or more windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequence indicating window opening events, also passed to the closing selector to obtain a sequence of window closing events. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + Observable sequence whose elements denote the creation of new windows. + A function invoked to define the closing of each produced window. + An observable sequence of windows. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window boundary events. + Source sequence to produce windows over. + Sequence of window boundary markers. The current window is closed and a new window is opened upon receiving a boundary marker. + An observable sequence of windows. + or is null. + + + + Merges two observable sequences into one observable sequence by combining their elements in a pairwise fashion. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Sixteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges an observable sequence and an enumerable sequence into one observable sequence by using the selector function. + + The type of the elements in the first observable source sequence. + The type of the elements in the second enumerable source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second enumerable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Hides the identity of an observable sequence. + + The type of the elements in the source sequence. + An observable sequence whose identity to hide. + An observable sequence that hides the identity of the source sequence. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Number of elements to skip between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than or equal to zero. + + + + Dematerializes the explicit notification values of an observable sequence as implicit notifications. + + The type of the elements materialized in the source sequence notification objects. + An observable sequence containing explicit notification values which have to be turned into implicit notifications. + An observable sequence exhibiting the behavior corresponding to the source sequence's notification values. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + An observable sequence only containing the distinct contiguous elements from the source sequence. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct contiguous elements from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + Equality comparer for computed key values. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or or is null. + + + + Invokes an action for each element in the observable sequence, and propagates all observer messages through the result sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or or is null. + + + + Invokes the observer's methods for each message in the source sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Observer whose methods to invoke as part of the source sequence's observation. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes a specified action after the source observable sequence terminates gracefully or exceptionally. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke after the source observable sequence terminates. + Source sequence with the action-invoking termination behavior applied. + or is null. + + + + Ignores all elements in an observable sequence leaving only the termination messages. + + The type of the elements in the source sequence. + Source sequence. + An empty observable sequence that signals termination, successful or exceptional, of the source sequence. + is null. + + + + Materializes the implicit notifications of an observable sequence as explicit notification values. + + The type of the elements in the source sequence. + An observable sequence to get notification values for. + An observable sequence containing the materialized notification values from the source sequence. + is null. + + + + Repeats the observable sequence indefinitely. + + The type of the elements in the source sequence. + Observable sequence to repeat. + The observable sequence producing the elements of the given sequence repeatedly and sequentially. + is null. + + + + Repeats the observable sequence a specified number of times. + + The type of the elements in the source sequence. + Observable sequence to repeat. + Number of times to repeat the sequence. + The observable sequence producing the elements of the given sequence repeatedly. + is null. + is less than zero. + + + + Repeats the source observable sequence until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + + + + Repeats the source observable sequence the specified number of times or until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + Number of times to repeat the sequence. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + is less than zero. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to accumulate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to accumulate over. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Bypasses a specified number of elements at the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to bypass at the end of the source sequence. + An observable sequence containing the source sequence elements except for the bypassed ones at the end. + is null. + is less than zero. + + This operator accumulates a queue with a length enough to store the first elements. As more elements are + received, elements are taken from the front of the queue and produced on the result sequence. This causes elements to be delayed. + + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Returns a specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a specified number of contiguous elements from the end of an observable sequence, using the specified scheduler to drain the queue. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + Scheduler used to drain the queue upon completion of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + or is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a list with the specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing a single list with the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements. Upon completion of the + source sequence, this buffer is produced on the result sequence. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + An observable sequence of windows. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Number of elements to skip between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than or equal to zero. + + + + Converts the elements of an observable sequence to the specified type. + + The type to convert the elements in the source sequence to. + The observable sequence that contains the elements to be converted. + An observable sequence that contains each element of the source sequence converted to the specified type. + is null. + + + + Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), whose default value will be taken if the sequence is empty. + The sequence to return a default value for if it is empty. + An observable sequence that contains the default value for the TSource type if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns the elements of the specified sequence or the specified value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), and the specified default value which will be taken if the sequence is empty. + The sequence to return the specified value for if it is empty. + The value to return if the sequence is empty. + An observable sequence that contains the specified default value if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns an observable sequence that contains only distinct elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + An observable sequence only containing the distinct elements from the source sequence. + is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct elements from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + Equality comparer for source elements. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Groups the elements of an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered. + + or or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or is null. + + + + Correlates the elements of two sequences based on overlapping durations, and groups the results. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any element of the left sequence with overlapping elements from the right observable sequence. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Correlates the elements of two sequences based on overlapping durations. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any two overlapping elements of the left and right observable sequences. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Filters the elements of an observable sequence based on the specified type. + + The type to filter the elements in the source sequence on. + The observable sequence that contains the elements to be filtered. + An observable sequence that contains elements from the input sequence of type TResult. + is null. + + + + Projects each element of an observable sequence into a new form. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of an observable sequence into a new form by incorporating the element's index. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the other sequence and the elements in the result sequence. + An observable sequence of elements to project. + An observable sequence to project each element from the source sequence onto. + An observable sequence whose elements are the result of projecting each source element onto the other sequence and merging all the resulting sequences together. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to a task and merges all of the task results into one observable sequence. + + The type of the elements in the source sequence. + The type of the result produced by the projected tasks and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of the tasks executed for each element of the input sequence. + This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + or is null. + + + + Projects each element of an observable sequence to a task with cancellation support and merges all of the task results into one observable sequence. + + The type of the elements in the source sequence. + The type of the result produced by the projected tasks and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of the tasks executed for each element of the input sequence. + This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to a task, invokes the result selector for the source element and the task result, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the results produced by the projected intermediate tasks. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate task results. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element. + or or is null. + This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + + + + Projects each element of an observable sequence to a task with cancellation support, invokes the result selector for the source element and the task result, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the results produced by the projected intermediate tasks. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate task results. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element. + or or is null. + This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element. + A transform function to apply when an error occurs in the source sequence. + A transform function to apply when the end of the source sequence is reached. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element; the second parameter represents the index of the source element. + A transform function to apply when an error occurs in the source sequence; the second parameter represents the index of the source element. + A transform function to apply when the end of the source sequence is reached; the second parameter represents the number of elements observed. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + The index of each source element is used in the projected form of that element. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Bypasses a specified number of elements in an observable sequence and then returns the remaining elements. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to skip before returning the remaining elements. + An observable sequence that contains the elements that occur after the specified index in the input sequence. + is null. + is less than zero. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Returns a specified number of contiguous elements from the start of an observable sequence. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + An observable sequence that contains the specified number of elements from the start of the input sequence. + is null. + is less than zero. + + + + Returns a specified number of contiguous elements from the start of an observable sequence, using the specified scheduler for the edge case of Take(0). + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + Scheduler used to produce an OnCompleted message in case count is set to 0. + An observable sequence that contains the specified number of elements from the start of the input sequence. + or is null. + is less than zero. + + + + Returns elements from an observable sequence as long as a specified condition is true. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Returns elements from an observable sequence as long as a specified condition is true. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Filters the elements of an observable sequence based on a predicate. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a condition. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Filters the elements of an observable sequence based on a predicate by incorporating the element's index. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a conditio; the second parameter of the function represents the index of the source element. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a buffer. + Maximum element count of a buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Time shifts the observable sequence by the specified relative time duration. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence by the specified relative time duration, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence based on a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or is null. + + + + Time shifts the observable sequence based on a subscription delay and a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Sequence indicating the delay for the subscription to the source. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or or is null. + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Time-shifted sequence. + is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Returns an observable sequence that produces a value after each period. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Returns an observable sequence that produces a value after each period, using the specified scheduler to run timers and to send out observer messages. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + is null. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Samples the observable sequence at each interval. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Sampled observable sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the observable sequence at each interval, using the specified scheduler to run sampling timers. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Scheduler to run the sampling timer on. + Sampled observable sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the source observable sequence using a samper observable sequence producing sampling ticks. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + The type of the elements in the sampling sequence. + Source sequence to sample. + Sampling tick sequence. + Sampled observable sequence. + or is null. + + + + Skips elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements for the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements from the observable source sequence until the specified start time. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + An observable sequence with the elements skipped until the specified start time. + is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Skips elements from the observable source sequence until the specified start time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + Scheduler to run the timer on. + An observable sequence with the elements skipped until the specified start time. + or is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Takes elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Takes elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Returns elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified schedulers to run timers and to drain the collected elements. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + Scheduler to drain the collected elements. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Takes elements for the specified duration until the specified end time. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + An observable sequence with the elements taken until the specified end time. + is null. + + + + Takes elements for the specified duration until the specified end time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + Scheduler to run the timer on. + An observable sequence with the elements taken until the specified end time. + or is null. + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + The throttled sequence. + is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration, using the specified scheduler to run throttling timers. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + Scheduler to run the throttle timers on. + The throttled sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another value within a computed throttle duration. + + The type of the elements in the source sequence. + The type of the elements in the throttle sequences selected for each element in the source sequence. + Source sequence to throttle. + Selector function to retrieve a sequence indicating the throttle duration for each given element. + The throttled sequence. + or is null. + + This operator throttles the source sequence by holding on to each element for the duration denoted by . + If another element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this + whole process. For streams where the duration computed by applying the to each element overlaps with + the occurrence of the successor element, the resulting stream won't produce any elements. In order to reduce the volume of a stream whilst + guaranteeing the periodic production of elements, consider using the Observable.Sample set of operators. + + + + + Records the time interval between consecutive elements in an observable sequence. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + An observable sequence with time interval information on elements. + is null. + + + + Records the time interval between consecutive elements in an observable sequence, using the specified scheduler to compute time intervals. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + Scheduler used to compute time intervals. + An observable sequence with time interval information on elements. + or is null. + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + The source sequence with a TimeoutException in case of a timeout. + is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + The source sequence with a TimeoutException in case of a timeout. + is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or is null. + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or or is null. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + An observable sequence that produces a value after the due time has elapsed. + + + + Returns an observable sequence that produces a single value at the specified absolute due time. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + An observable sequence that produces a value at due time. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after due time has elapsed and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed, using the specified scheduler to run the timer. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after the due time has elapsed. + is null. + + + + Returns an observable sequence that produces a single value at the specified absolute due time, using the specified scheduler to run the timer. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value at due time. + is null. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run timers. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value after due time has elapsed and then each period. + is less than TimeSpan.Zero. + is null. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time, using the specified scheduler to run timers. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + is null. + + + + Timestamps each element in an observable sequence using the local system clock. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + An observable sequence with timestamp information on elements. + is null. + + + + Timestamp each element in an observable sequence using the clock of the specified scheduler. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + Scheduler used to compute timestamps. + An observable sequence with timestamp information on elements. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + The sequence of windows. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of windows. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Internal interface describing the LINQ to Events query language. + + + + + Base class for classes that expose an observable sequence as a well-known event pattern (sender, event arguments). + Contains functionality to maintain a map of event handler delegates to observable sequence subscriptions. Subclasses + should only add an event with custom add and remove methods calling into the base class's operations. + + The type of the sender that raises the event. + The type of the event data generated by the event. + + + + Creates a new event pattern source. + + Source sequence to expose as an event. + Delegate used to invoke the event for each element of the sequence. + or is null. + + + + Adds the specified event handler, causing a subscription to the underlying source. + + Event handler to add. The same delegate should be passed to the Remove operation in order to remove the event handler. + Invocation delegate to raise the event in the derived class. + or is null. + + + + Removes the specified event handler, causing a disposal of the corresponding subscription to the underlying source that was created during the Add operation. + + Event handler to remove. This should be the same delegate as one that was passed to the Add operation. + is null. + + + + Represents a .NET event invocation consisting of the weakly typed object that raised the event and the data that was generated by the event. + + The type of the event data generated by the event. + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + The type of the sender that raised the event. + The type of the event data generated by the event. + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Determines whether the current EventPattern<TSender, TEventArgs> object represents the same event as a specified EventPattern<TSender, TEventArgs> object. + + An object to compare to the current EventPattern<TSender, TEventArgs> object. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>. + + The System.Object to compare with the current EventPattern<TSender, TEventArgs>. + true if the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>; otherwise, false. + + + + Returns the hash code for the current EventPattern<TSender, TEventArgs> instance. + + A hash code for the current EventPattern<TSender, TEventArgs> instance. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent the same event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent a different event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects don't represent the same event; otherwise, false. + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Base class for historical schedulers, which are virtual time schedulers that use DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Base class for virtual time schedulers. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts the virtual time scheduler. + + + + + Stops the virtual time scheduler. + + + + + Advances the scheduler's clock to the specified time, running all work till that point. + + Absolute time to advance the scheduler's clock to. + is in the past. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan. + + Relative time to advance the scheduler's clock by. + is negative. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time. + + Relative time to advance the scheduler's clock by. + is negative. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Discovers scheduler services by interface type. The base class implementation supports + only the IStopwatchProvider service. To influence service discovery - such as adding + support for other scheduler services - derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Gets whether the scheduler is enabled to run work. + + + + + Gets the comparer used to compare absolute time values. + + + + + Gets the scheduler's absolute time clock value. + + + + + Gets the scheduler's notion of current time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial clock value. + + + + Creates a new historical scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Provides a virtual time scheduler that uses DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Base class for virtual time schedulers using a priority queue for scheduled items. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the resulting sequence, after transformation through the subject. + + + + Creates an observable that can be connected and disconnected from its source. + + Underlying observable source sequence that can be connected and disconnected from the wrapper. + Subject exposed by the connectable observable, receiving data from the underlying source sequence upon connection. + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable object used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Subscribes an observer to the observable sequence. No values from the underlying observable source will be received unless a connection was established through the Connect method. + + Observer that will receive values from the underlying observable source when the current ConnectableObservable instance is connected through a call to Connect. + Disposable used to unsubscribe from the observable sequence. + + + + Provides a set of static methods for creating subjects. + + + + + Creates a subject from the specified observer and observable. + + The type of the elements received by the observer. + The type of the elements produced by the observable sequence. + The observer used to send messages to the subject. + The observable used to subscribe to messages sent from the subject. + Subject implemented using the given observer and observable. + or is null. + + + + Synchronizes the messages sent to the subject. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Subject whose messages are synchronized. + is null. + + + + Synchronizes the messages sent to the subject and notifies observers on the specified scheduler. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Scheduler to notify observers on. + Subject whose messages are synchronized and whose observers are notified on the given scheduler. + or is null. + + + + Represents the result of an asynchronous operation. + The last value before the OnCompleted notification, or the error received through OnError, is sent to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject that can only receive one value and that value is cached for all future observations. + + + + + Notifies all subscribed observers about the end of the sequence, also causing the last received value to be sent out (if any). + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Sends a value to the subject. The last value received before successful termination will be sent to all subscribed and future observers. + + The value to store in the subject. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Gets the last element of the subject, potentially blocking until the subject completes successfully or exceptionally. + + The last element of the subject. Throws an InvalidOperationException if no element was received. + The source sequence is empty. + + + + Indicates whether the subject has observers subscribed to it. + + + + + Gets whether the AsyncSubject has completed. + + + + + Represents a value that changes over time. + Observers can subscribe to the subject to receive the last (or initial) value and all subsequent notifications. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class which creates a subject that caches its last value and starts with the specified value. + + Initial value sent to observers when no other value has been received by the subject yet. + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject. + + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the specified exception. + + The exception to send to all currently subscribed observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all currently subscribed observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribes all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Abstract base class for join patterns. + + + + + Represents a join pattern over one observable sequence. + + The type of the elements in the first source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over two observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + + + + Creates a pattern that matches when all three observable sequences have an available element. + + The type of the elements in the third observable sequence. + Observable sequence to match with the two previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over three observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + + + + Creates a pattern that matches when all four observable sequences have an available element. + + The type of the elements in the fourth observable sequence. + Observable sequence to match with the three previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over four observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + + + + Creates a pattern that matches when all five observable sequences have an available element. + + The type of the elements in the fifth observable sequence. + Observable sequence to match with the four previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over five observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + + + + Creates a pattern that matches when all six observable sequences have an available element. + + The type of the elements in the sixth observable sequence. + Observable sequence to match with the five previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over six observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + + + + Creates a pattern that matches when all seven observable sequences have an available element. + + The type of the elements in the seventh observable sequence. + Observable sequence to match with the six previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over seven observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + + + + Creates a pattern that matches when all eight observable sequences have an available element. + + The type of the elements in the eighth observable sequence. + Observable sequence to match with the seven previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over eight observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + + + + Creates a pattern that matches when all nine observable sequences have an available element. + + The type of the elements in the ninth observable sequence. + Observable sequence to match with the eight previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over nine observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + + + + Creates a pattern that matches when all ten observable sequences have an available element. + + The type of the elements in the tenth observable sequence. + Observable sequence to match with the nine previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over ten observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + + + + Creates a pattern that matches when all eleven observable sequences have an available element. + + The type of the elements in the eleventh observable sequence. + Observable sequence to match with the ten previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over eleven observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + + + + Creates a pattern that matches when all twelve observable sequences have an available element. + + The type of the elements in the twelfth observable sequence. + Observable sequence to match with the eleven previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over twelve observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + + + + Creates a pattern that matches when all thirteen observable sequences have an available element. + + The type of the elements in the thirteenth observable sequence. + Observable sequence to match with the twelve previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over thirteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + + + + Creates a pattern that matches when all fourteen observable sequences have an available element. + + The type of the elements in the fourteenth observable sequence. + Observable sequence to match with the thirteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over fourteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + + + + Creates a pattern that matches when all fifteen observable sequences have an available element. + + The type of the elements in the fifteenth observable sequence. + Observable sequence to match with the fourteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over fifteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + + + + Creates a pattern that matches when all sixteen observable sequences have an available element. + + The type of the elements in the sixteenth observable sequence. + Observable sequence to match with the fifteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over sixteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents an execution plan for join patterns. + + The type of the results produced by the plan. + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed and future observers, subject to buffer trimming policies. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class with the specified buffer size, window and scheduler. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is less than zero. -or- is less than TimeSpan.Zero. + is null. + + + + Initializes a new instance of the class with the specified buffer size and window. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + is less than zero. -or- is less than TimeSpan.Zero. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified scheduler. + + Scheduler the observers are invoked on. + is null. + + + + Initializes a new instance of the class with the specified buffer size and scheduler. + + Maximum element count of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than zero. + + + + Initializes a new instance of the class with the specified buffer size. + + Maximum element count of the replay buffer. + is less than zero. + + + + Initializes a new instance of the class with the specified window and scheduler. + + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than TimeSpan.Zero. + + + + Initializes a new instance of the class with the specified window. + + Maximum time length of the replay buffer. + is less than TimeSpan.Zero. + + + + Notifies all subscribed and future observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Notifies all subscribed and future observers about the specified exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed and future observers about the end of the sequence. + + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribe all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + The System.Reactive.Threading.Tasks namespace contains helpers for the conversion between tasks and observable sequences. + + + + + Provides a set of static methods for converting tasks to observable sequences. + + + + + Returns an observable sequence that signals when the task completes. + + Task to convert to an observable sequence. + An observable sequence that produces a unit value when the task completes, or propagates the exception produced by the task. + is null. + If the specified task object supports cancellation, consider using instead. + + + + Returns an observable sequence that propagates the result of the task. + + The type of the result produced by the task. + Task to convert to an observable sequence. + An observable sequence that produces the task's result, or propagates the exception produced by the task. + is null. + If the specified task object supports cancellation, consider using instead. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + The state to use as the underlying task's AsyncState. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence. + The state to use as the underlying task's AsyncState. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Represents a value associated with time interval information. + The time interval can represent the time it took to produce the value, the interval relative to a previous value, the value's delivery time relative to a base, etc. + + The type of the value being annotated with time interval information. + + + + Constructs a time interval value. + + The value to be annotated with a time interval. + Time interval associated with the value. + + + + Determines whether the current TimeInterval<T> value has the same Value and Interval as a specified TimeInterval<T> value. + + An object to compare to the current TimeInterval<T> value. + true if both TimeInterval<T> values have the same Value and Interval; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has the same Value and Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values don't have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has a different Value or Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current TimeInterval<T>. + + The System.Object to compare with the current TimeInterval<T>. + true if the specified System.Object is equal to the current TimeInterval<T>; otherwise, false. + + + + Returns the hash code for the current TimeInterval<T> value. + + A hash code for the current TimeInterval<T> value. + + + + Returns a string representation of the current TimeInterval<T> value. + + String representation of the current TimeInterval<T> value. + + + + Gets the value. + + + + + Gets the interval. + + + + + Represents value with a timestamp on it. + The timestamp typically represents the time the value was received, using an IScheduler's clock to obtain the current time. + + The type of the value being timestamped. + + + + Constructs a timestamped value. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + + + + Determines whether the current Timestamped<T> value has the same Value and Timestamp as a specified Timestamped<T> value. + + An object to compare to the current Timestamped<T> value. + true if both Timestamped<T> values have the same Value and Timestamp; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has the same Value and Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values don't have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has a different Value or Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current Timestamped<T>. + + The System.Object to compare with the current Timestamped<T>. + true if the specified System.Object is equal to the current Timestamped<T>; otherwise, false. + + + + Returns the hash code for the current Timestamped<T> value. + + A hash code for the current Timestamped<T> value. + + + + Returns a string representation of the current Timestamped<T> value. + + String representation of the current Timestamped<T> value. + + + + Gets the value. + + + + + Gets the timestamp. + + + + + A helper class with a factory method for creating Timestamped<T> instances. + + + + + Creates an instance of a Timestamped<T>. This is syntactic sugar that uses type inference + to avoid specifying a type in a constructor call, which is very useful when using anonymous types. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + Creates a new timestamped value. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Could not find event '{0}' on object of type '{1}'.. + + + + + Looks up a localized string similar to Could not find event '{0}' on type '{1}'.. + + + + + Looks up a localized string similar to Add method should take 1 parameter.. + + + + + Looks up a localized string similar to The second parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Event is missing the add method.. + + + + + Looks up a localized string similar to Event is missing the remove method.. + + + + + Looks up a localized string similar to The event delegate must have a void return type.. + + + + + Looks up a localized string similar to The event delegate must have exactly two parameters.. + + + + + Looks up a localized string similar to Remove method should take 1 parameter.. + + + + + Looks up a localized string similar to The first parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Remove method of a WinRT event should take an EventRegistrationToken.. + + + + + Looks up a localized string similar to Sequence contains more than one element.. + + + + + Looks up a localized string similar to Sequence contains more than one matching element.. + + + + + Looks up a localized string similar to Sequence contains no elements.. + + + + + Looks up a localized string similar to Sequence contains no matching element.. + + + + + Looks up a localized string similar to {0} cannot be called when the scheduler is already running. Try using Sleep instead.. + + + + diff --git a/packages/Rx-Linq.2.1.30214.0/lib/Net40/System.Reactive.Linq.dll b/packages/Rx-Linq.2.1.30214.0/lib/Net40/System.Reactive.Linq.dll new file mode 100644 index 0000000000000000000000000000000000000000..ebac11d305bbea2df8e7b137b0478eaa308e465a GIT binary patch literal 686664 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

XVE-fY0nqYJl@t}{Xy}| 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

Dcrxu=CcxvIPg{PMLsaEbM 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

V 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⪚LHpcd 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 + + + System.Reactive.Linq + + + +

+ The System.Reactive.Joins namespace contains classes used to express join patterns over observable sequences using fluent method syntax. + + + + + Provides a set of extension methods for virtual time scheduling. + + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Attribute applied to static classes providing expression tree forms of query methods, + mapping those to the corresponding methods for local query execution on the specified + target class type. + + + + + Creates a new mapping to the specified local execution query method implementation type. + + Type with query methods for local execution. + + + + Gets the type with the implementation of local query methods. + + + + + Provides a set of static methods for writing in-memory queries over observable sequences. + + + + + Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. + The loop can be quit prematurely by setting the specified cancellation token. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Cancellation token used to stop the loop. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. + The loop can be quit prematurely by setting the specified cancellation token. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Cancellation token used to stop the loop. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Uses to determine which source in to return, choosing if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Default source to select in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence on the specified scheduler if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Scheduler to generate an empty sequence on in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated after each repeated completed. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated upon the completion of an iteration through the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Concatenates the observable sequences obtained by running the for each element in the given enumerable . + + The type of the elements in the enumerable source sequence. + The type of the elements in the observable result sequence. + Enumerable source for which each element will be mapped onto an observable source that will be concatenated in the result sequence. + Function to select an observable source for each element in the . + The observable sequence obtained by concatenating the sources returned by for each element in the . + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, select the sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Sequence returned in case evaluates false. + if evaluates true; otherwise. + or or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + if evaluates true; an empty sequence otherwise. + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence generated on the specified scheduler. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Scheduler to generate an empty sequence on in case evaluates false. + if evaluates true; an empty sequence otherwise. + or or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated before each repeated is subscribed to. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated before subscription to the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the fourteenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the fourteenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Invokes the specified function asynchronously, surfacing the result through an observable sequence. + + The type of the result returned by the function. + Function to run asynchronously. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence + + The type of the result returned by the function. + Function to run asynchronously. + Scheduler to run the function on. + An observable sequence exposing the function's result value, or an exception. + or is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the asynchronous function, surfacing the result through an observable sequence. + + The type of the result returned by the asynchronous function. + Asynchronous function to run. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the asynchronous function, surfacing the result through an observable sequence. + The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information. + + The type of the result returned by the asynchronous function. + Asynchronous function to run. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + If any subscription to the resulting sequence is disposed, the CancellationToken is set. The observer associated to the disposed + subscription won't see the TaskCanceledException, but other observers will. You can protect against this using the Catch operator. + Be careful when handing out the resulting sequence because of this behavior. The most common use is to have a single subscription + to the resulting sequence, which controls the CancellationToken state. Alternatively, you can control subscription behavior using + multicast operators. + + + + + + + Invokes the action asynchronously, surfacing the result through an observable sequence. + + Action to run asynchronously. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the action asynchronously on the specified scheduler, surfacing the result through an observable sequence. + + Action to run asynchronously. + Scheduler to run the action on. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + or is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the asynchronous action, surfacing the result through an observable sequence. + + Asynchronous action to run. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the asynchronous action, surfacing the result through an observable sequence. + The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information. + + Asynchronous action to run. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + If any subscription to the resulting sequence is disposed, the CancellationToken is set. The observer associated to the disposed + subscription won't see the TaskCanceledException, but other observers will. You can protect against this using the Catch operator. + Be careful when handing out the resulting sequence because of this behavior. The most common use is to have a single subscription + to the resulting sequence, which controls the CancellationToken state. Alternatively, you can control subscription behavior using + multicast operators. + + + + + + + Converts to asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. + + The type of the result returned by the asynchronous function. + Asynchronous function to convert. + An observable sequence exposing the result of invoking the function, or an exception. + is null. + + + + Converts to asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. + The CancellationToken passed to the asynchronous function is tied to the observable sequence's subscription that triggered the function's invocation and can be used for best-effort cancellation. + + The type of the result returned by the asynchronous function. + Asynchronous function to convert. + An observable sequence exposing the result of invoking the function, or an exception. + is null. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous function will be signaled. + + + + Converts to asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. + + Asynchronous action to convert. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + + Converts to asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. + The CancellationToken passed to the asynchronous action is tied to the observable sequence's subscription that triggered the action's invocation and can be used for best-effort cancellation. + + Asynchronous action to convert. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous function will be signaled. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the sixteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the sixteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + The type of the sixteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + The type of the sixteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value, + and the specified result selector function is used to select the result value. + + The type of the elements in the source sequence. + The type of the accumulator value. + The type of the resulting value. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + A function to transform the final accumulator value into the result value. + An observable sequence containing a single element with the final accumulator value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to aggregate over. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether all elements of an observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains any elements. + + The type of the elements in the source sequence. + An observable sequence to check for non-emptiness. + An observable sequence containing a single element determining whether the source sequence contains any elements. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether any element of an observable sequence satisfies a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether any elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + (Asynchronous) The sum of the elements in the source sequence is larger than . + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using the default equality comparer. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using a specified System.Collections.Generic.IEqualityComparer<T>. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An equality comparer to compare elements. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the element at a specified index in a sequence. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence. + is null. + is less than zero. + (Asynchronous) is greater than or equal to the number of elements in the source sequence. + + + + Returns the element at a specified index in a sequence or a default value if the index is out of range. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence, or a default value if the index is outside the bounds of the source sequence. + is null. + is less than zero. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Determines whether an observable sequence is empty. + + The type of the elements in the source sequence. + An observable sequence to check for emptiness. + An observable sequence containing a single element determining whether the source sequence is empty. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + An observable sequence containing a single element with the maximum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + An observable sequence containing a single element with the minimum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the only element of an observable sequence, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence. + is null. + (Asynchronous) The source sequence contains more than one element. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence, or a default value if no such element exists. + is null. + (Asynchronous) The source sequence contains more than one element. + + + + Returns the only element of an observable sequence that matches the predicate, or a default value if no such element exists; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + (Asynchronous) The sequence contains more than one element that satisfies the condition in the predicate. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates an array from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get an array of elements for. + An observable sequence containing a single element with an array containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a list from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get a list of elements for. + An observable sequence containing a single element with a list containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes to the observable sequence, making it hot. + + The type of the elements in the source sequence. + Source sequence to await. + Object that can be awaited. + is null. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes and connects to the observable sequence, making it hot. + + The type of the elements in the source sequence. + Source sequence to await. + Object that can be awaited. + is null. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes to the observable sequence, making it hot. The supplied CancellationToken can be used to cancel the subscription. + + The type of the elements in the source sequence. + Source sequence to await. + Cancellation token. + Object that can be awaited. + is null. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes and connects to the observable sequence, making it hot. The supplied CancellationToken can be used to cancel the subscription and connection. + + The type of the elements in the source sequence. + Source sequence to await. + Cancellation token. + Object that can be awaited. + is null. + + + + Multicasts the source sequence notifications through the specified subject to the resulting connectable observable. Upon connection of the + connectable observable, the subject is subscribed to the source exactly one, and messages are forwarded to the observers registered with + the connectable observable. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be pushed into the specified subject. + Subject to push source elements into. + A connectable observable sequence that upon connection causes the source sequence to push results into the specified subject. + or is null. + + + + Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each + subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's + invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements produced by the intermediate subject. + The type of the elements in the result sequence. + Source sequence which will be multicasted in the specified selector function. + Factory function to create an intermediate subject through which the source sequence's elements will be multicast to the selector function. + Selector function which can use the multicasted source sequence subject to the policies enforced by the created subject. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Initial value received by observers upon subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + Initial value received by observers upon subscription. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will only receive the last notification of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will only receive the last notification of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + + The type of the elements in the source sequence. + Connectable observable sequence. + An observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all the notifications of the source. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + Subscribers will receive all the notifications of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Produces an enumerable sequence of consecutive (possibly empty) chunks of the source sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns consecutive (possibly empty) chunks upon each iteration. + is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create a new collector object. + Merges a sequence element with the current collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create the initial collector object. + Merges a sequence element with the current collector. + Factory to replace the current collector by a new collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or or is null. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Invokes an action for each element in the observable sequence, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Returns an enumerator that enumerates all values of the observable sequence. + + The type of the elements in the source sequence. + An observable sequence to get an enumerator for. + The enumerator that can be used to enumerate over the elements in the observable sequence. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Returns an enumerable sequence whose enumeration returns the latest observed element in the source observable sequence. + Enumerators on the resulting sequence will never produce the same element repeatedly, and will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns the last sampled element upon each iteration and subsequently blocks until the next element in the observable source sequence becomes available. + + + + Returns an enumerable sequence whose enumeration returns the most recently observed element in the source observable sequence, using the specified initial value in case no element has been sampled yet. + Enumerators on the resulting sequence never block and can produce the same element repeatedly. + + The type of the elements in the source sequence. + Source observable sequence. + Initial value that will be yielded by the enumerable sequence if no element has been sampled yet. + The enumerable sequence that returns the last sampled element upon each iteration. + is null. + + + + Returns an enumerable sequence whose enumeration blocks until the next element in the source observable sequence becomes available. + Enumerators on the resulting sequence will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that blocks upon each iteration until the next element in the observable source sequence becomes available. + is null. + + + + Returns the only element of an observable sequence, and throws an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence. + is null. + The source sequence contains more than one element. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and throws an exception if there is not exactly one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method throws an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence, or a default value if no such element exists. + is null. + The source sequence contains more than one element. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists; this method throws an exception if there is more than one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + The sequence contains more than one element that satisfies the condition in the predicate. + + + + + Waits for the observable sequence to complete and returns the last element of the sequence. + If the sequence terminates with an OnError notification, the exception is throw. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + This only invokes observer callbacks on a scheduler. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a scheduler, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + This only invokes observer callbacks on a synchronization context. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a synchronization context, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified scheduler. In order to invoke observer + callbacks on a scheduler, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified synchronization context. In order to invoke observer + callbacks on a synchronization context, use . + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently. + This overload is useful to "fix" an observable sequence that exhibits concurrent callbacks on individual observers, which is invalid behavior for the query processor. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + It's invalid behavior - according to the observer grammar - for a sequence to exhibit concurrent callbacks on a given observer. + This operator can be used to "fix" a source that doesn't conform to this rule. + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently, using the specified gate object. + This overload is useful when writing n-ary query operators, in order to prevent concurrent callbacks from different sources by synchronizing on a common gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Subscribes an observer to an enumerable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Disposable object that can be used to unsubscribe the observer from the enumerable + or is null. + + + + Subscribes an observer to an enumerable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Scheduler to perform the enumeration on. + Disposable object that can be used to unsubscribe the observer from the enumerable + or or is null. + + + + Converts an observable sequence to an enumerable sequence. + + The type of the elements in the source sequence. + An observable sequence to convert to an enumerable sequence. + The enumerable sequence containing the elements in the observable sequence. + is null. + + + + Exposes an observable sequence as an object with an Action-based .NET event. + + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with an Action<TSource>-based .NET event. + + The type of the elements in the source sequence. + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with a .NET event, conforming to the standard .NET event pattern. + + The type of the event data generated by the event. + Observable source sequence. + The event source object. + is null. + + + + Converts an enumerable sequence to an observable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + The observable sequence whose elements are pulled from the given enumerable sequence. + is null. + + + + Converts an enumerable sequence to an observable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + Scheduler to run the enumeration of the input sequence on. + The observable sequence whose elements are pulled from the given enumerable sequence. + or is null. + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to produce elements. + The observable sequence surfacing the elements produced by the asynchronous method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to produce elements. + The observable sequence surfacing the elements produced by the asynchronous method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Observable factory function to invoke for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger an invocation of the given observable factory function. + is null. + + + + Returns an observable sequence that starts the specified asynchronous factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Asynchronous factory function to start for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger the given asynchronous observable factory function to be started. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Returns an observable sequence that starts the specified cancellable asynchronous factory function whenever a new observer subscribes. + The CancellationToken passed to the asynchronous factory function is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Asynchronous factory function to start for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger the given asynchronous observable factory function to be started. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous observable factory function will be signaled. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence with no elements. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + An observable sequence with no elements. + is null. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + The generated sequence. + or or is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements, using the specified scheduler to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Scheduler on which to run the generator loop. + The generated sequence. + or or or is null. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence whose observers will never get called. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence whose observers will never get called. + + + + Generates an observable sequence of integral numbers within a specified range. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + + + + Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to send out observer messages. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + Scheduler to run the generator loop on. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + is null. + + + + Generates an observable sequence that repeats the given element infinitely. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + An observable sequence that repeats the given element infinitely. + + + + Generates an observable sequence that repeats the given element infinitely, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element infinitely. + is null. + + + + Generates an observable sequence that repeats the given element the specified number of times. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + + + + Generates an observable sequence that repeats the given element the specified number of times, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + is null. + + + + Returns an observable sequence that contains a single element. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + An observable sequence containing the single specified element. + + + + Returns an observable sequence that contains a single element, using the specified scheduler to send out observer messages. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + Scheduler to send the single element on. + An observable sequence containing the single specified element. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Factory function to obtain a resource object. + Factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. The resource is obtained and used through asynchronous methods. + The CancellationToken passed to the asynchronous methods is tied to the returned disposable subscription, allowing best-effort cancellation at any stage of the resource acquisition or usage. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Asynchronous factory function to obtain a resource object. + Asynchronous factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous resource factory and observable factory functions will be signaled. + + + + Creates a pattern that matches when both observable sequences have an available element. + + The type of the elements in the left sequence. + The type of the elements in the right sequence. + Observable sequence to match with the right sequence. + Observable sequence to match with the left sequence. + Pattern object that matches when both observable sequences have an available element. + or is null. + + + + Matches when the observable sequence has an available element and projects the element by invoking the selector function. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, returned by the selector function. + Observable sequence to apply the selector on. + Selector that will be invoked for elements in the source sequence. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + or is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results from matching several patterns. + is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results form matching several patterns. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that surfaces either of the given sequences, whichever reacted first. + or is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + A function invoked to define the boundaries of the produced buffers. A new buffer is started when the previous one is closed. + An observable sequence of buffers. + or is null. + + + + Projects each element of an observable sequence into zero or more buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequence indicating buffer opening events, also passed to the closing selector to obtain a sequence of buffer closing events. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + Observable sequence whose elements denote the creation of new buffers. + A function invoked to define the closing of each produced buffer. + An observable sequence of buffers. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer boundary events. + Source sequence to produce buffers over. + Sequence of buffer boundary markers. The current buffer is closed and a new buffer is opened upon receiving a boundary marker. + An observable sequence of buffers. + or is null. + + + + Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler. + + The type of the elements in the source sequence and sequences returned by the exception handler function. + The type of the exception to catch and handle. Needs to derive from . + Source sequence. + Exception handler function, producing another observable sequence. + An observable sequence containing the source sequence's elements, followed by the elements produced by the handler's resulting observable sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source sequence and handler sequence. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results when an error occurred in the first sequence. + An observable sequence containing the first sequence's elements, followed by the elements of the second sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Merges two observable sequences into one observable sequence by using the selector function whenever one of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke whenever either of the sources produces an element. + An observable sequence containing the result of combining elements of both sources using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Sixteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke whenever any of the sources produces an element. For efficiency, the input list is reused after the selector returns. Either aggregate or copy the values during the function call. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful termination of the first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that contains the elements of the first sequence, followed by those of the second the sequence. + or is null. + + + + Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all inner observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + An observable sequence that contains the elements of each observed inner sequence, in sequential order. + is null. + + + + Concatenates all task results, as long as the previous task terminated successfully. + + The type of the results produced by the tasks. + Observable sequence of tasks. + An observable sequence that contains the results of each task, in sequential order. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a concatenation operation using . + + + + Merges elements from all inner observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that merges the elements of the inner sequences. + is null. + + + + Merges results from all source tasks into a single observable sequence. + + The type of the results produced by the source tasks. + Observable sequence of tasks. + The observable sequence that merges the results of the source tasks. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a merge operation using . + + + + Merges elements from all inner observable sequences into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + Maximum number of inner observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the inner sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the observable sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences, and using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + is less than or equal to zero. + + + + Merges elements from two observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + The observable sequence that merges the elements of the given sequences. + or is null. + + + + Merges elements from two observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + Scheduler used to introduce concurrency for making subscriptions to the given sequences. + The observable sequence that merges the elements of the given sequences. + or or is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful or exceptional termination of the first. + + The type of the elements in the source sequences. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results after the first sequence terminates. + An observable sequence that concatenates the first and second sequence, even if the first sequence terminates exceptionally. + or is null. + + + + Concatenates all of the specified observable sequences, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Returns the elements from the source observable sequence only after the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of skip behavior. + Source sequence to propagate elements for. + Observable sequence that triggers propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation. + or is null. + + + + Switches between the inner observable sequences such that the resulting sequence always produces elements from the most recently received inner observable sequence. + Each time a new inner observable sequence is received, the previous inner observable sequence is unsubscribed from. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received. + is null. + + + + Switches between the tasks such that the resulting sequence always produces results from the most recently received task. + Each time a new task is received, the previous task's result is ignored. + + The type of the results produced by the source tasks. + Observable sequence of tasks. + The observable sequence that at any point in time produces the result of the most recent task that has been received. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a switch operation using . + + + + Returns the elements from the source observable sequence until the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of take behavior. + Source sequence to propagate elements for. + Observable sequence that terminates propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + A function invoked to define the boundaries of the produced windows. A new window is started when the previous one is closed. + An observable sequence of windows. + or is null. + + + + Projects each element of an observable sequence into zero or more windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequence indicating window opening events, also passed to the closing selector to obtain a sequence of window closing events. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + Observable sequence whose elements denote the creation of new windows. + A function invoked to define the closing of each produced window. + An observable sequence of windows. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window boundary events. + Source sequence to produce windows over. + Sequence of window boundary markers. The current window is closed and a new window is opened upon receiving a boundary marker. + An observable sequence of windows. + or is null. + + + + Merges two observable sequences into one observable sequence by combining their elements in a pairwise fashion. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Sixteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges an observable sequence and an enumerable sequence into one observable sequence by using the selector function. + + The type of the elements in the first observable source sequence. + The type of the elements in the second enumerable source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second enumerable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Hides the identity of an observable sequence. + + The type of the elements in the source sequence. + An observable sequence whose identity to hide. + An observable sequence that hides the identity of the source sequence. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Number of elements to skip between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than or equal to zero. + + + + Dematerializes the explicit notification values of an observable sequence as implicit notifications. + + The type of the elements materialized in the source sequence notification objects. + An observable sequence containing explicit notification values which have to be turned into implicit notifications. + An observable sequence exhibiting the behavior corresponding to the source sequence's notification values. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + An observable sequence only containing the distinct contiguous elements from the source sequence. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct contiguous elements from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + Equality comparer for computed key values. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or or is null. + + + + Invokes an action for each element in the observable sequence, and propagates all observer messages through the result sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or or is null. + + + + Invokes the observer's methods for each message in the source sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Observer whose methods to invoke as part of the source sequence's observation. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes a specified action after the source observable sequence terminates gracefully or exceptionally. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke after the source observable sequence terminates. + Source sequence with the action-invoking termination behavior applied. + or is null. + + + + Ignores all elements in an observable sequence leaving only the termination messages. + + The type of the elements in the source sequence. + Source sequence. + An empty observable sequence that signals termination, successful or exceptional, of the source sequence. + is null. + + + + Materializes the implicit notifications of an observable sequence as explicit notification values. + + The type of the elements in the source sequence. + An observable sequence to get notification values for. + An observable sequence containing the materialized notification values from the source sequence. + is null. + + + + Repeats the observable sequence indefinitely. + + The type of the elements in the source sequence. + Observable sequence to repeat. + The observable sequence producing the elements of the given sequence repeatedly and sequentially. + is null. + + + + Repeats the observable sequence a specified number of times. + + The type of the elements in the source sequence. + Observable sequence to repeat. + Number of times to repeat the sequence. + The observable sequence producing the elements of the given sequence repeatedly. + is null. + is less than zero. + + + + Repeats the source observable sequence until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + + + + Repeats the source observable sequence the specified number of times or until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + Number of times to repeat the sequence. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + is less than zero. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to accumulate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to accumulate over. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Bypasses a specified number of elements at the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to bypass at the end of the source sequence. + An observable sequence containing the source sequence elements except for the bypassed ones at the end. + is null. + is less than zero. + + This operator accumulates a queue with a length enough to store the first elements. As more elements are + received, elements are taken from the front of the queue and produced on the result sequence. This causes elements to be delayed. + + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Returns a specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a specified number of contiguous elements from the end of an observable sequence, using the specified scheduler to drain the queue. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + Scheduler used to drain the queue upon completion of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + or is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a list with the specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing a single list with the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements. Upon completion of the + source sequence, this buffer is produced on the result sequence. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + An observable sequence of windows. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Number of elements to skip between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than or equal to zero. + + + + Converts the elements of an observable sequence to the specified type. + + The type to convert the elements in the source sequence to. + The observable sequence that contains the elements to be converted. + An observable sequence that contains each element of the source sequence converted to the specified type. + is null. + + + + Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), whose default value will be taken if the sequence is empty. + The sequence to return a default value for if it is empty. + An observable sequence that contains the default value for the TSource type if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns the elements of the specified sequence or the specified value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), and the specified default value which will be taken if the sequence is empty. + The sequence to return the specified value for if it is empty. + The value to return if the sequence is empty. + An observable sequence that contains the specified default value if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns an observable sequence that contains only distinct elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + An observable sequence only containing the distinct elements from the source sequence. + is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct elements from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + Equality comparer for source elements. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Groups the elements of an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered. + + or or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or is null. + + + + Correlates the elements of two sequences based on overlapping durations, and groups the results. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any element of the left sequence with overlapping elements from the right observable sequence. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Correlates the elements of two sequences based on overlapping durations. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any two overlapping elements of the left and right observable sequences. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Filters the elements of an observable sequence based on the specified type. + + The type to filter the elements in the source sequence on. + The observable sequence that contains the elements to be filtered. + An observable sequence that contains elements from the input sequence of type TResult. + is null. + + + + Projects each element of an observable sequence into a new form. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of an observable sequence into a new form by incorporating the element's index. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the other sequence and the elements in the result sequence. + An observable sequence of elements to project. + An observable sequence to project each element from the source sequence onto. + An observable sequence whose elements are the result of projecting each source element onto the other sequence and merging all the resulting sequences together. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to a task and merges all of the task results into one observable sequence. + + The type of the elements in the source sequence. + The type of the result produced by the projected tasks and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of the tasks executed for each element of the input sequence. + This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + or is null. + + + + Projects each element of an observable sequence to a task with cancellation support and merges all of the task results into one observable sequence. + + The type of the elements in the source sequence. + The type of the result produced by the projected tasks and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of the tasks executed for each element of the input sequence. + This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to a task, invokes the result selector for the source element and the task result, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the results produced by the projected intermediate tasks. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate task results. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element. + or or is null. + This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + + + + Projects each element of an observable sequence to a task with cancellation support, invokes the result selector for the source element and the task result, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the results produced by the projected intermediate tasks. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate task results. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element. + or or is null. + This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element. + A transform function to apply when an error occurs in the source sequence. + A transform function to apply when the end of the source sequence is reached. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element; the second parameter represents the index of the source element. + A transform function to apply when an error occurs in the source sequence; the second parameter represents the index of the source element. + A transform function to apply when the end of the source sequence is reached; the second parameter represents the number of elements observed. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + The index of each source element is used in the projected form of that element. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Bypasses a specified number of elements in an observable sequence and then returns the remaining elements. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to skip before returning the remaining elements. + An observable sequence that contains the elements that occur after the specified index in the input sequence. + is null. + is less than zero. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Returns a specified number of contiguous elements from the start of an observable sequence. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + An observable sequence that contains the specified number of elements from the start of the input sequence. + is null. + is less than zero. + + + + Returns a specified number of contiguous elements from the start of an observable sequence, using the specified scheduler for the edge case of Take(0). + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + Scheduler used to produce an OnCompleted message in case count is set to 0. + An observable sequence that contains the specified number of elements from the start of the input sequence. + or is null. + is less than zero. + + + + Returns elements from an observable sequence as long as a specified condition is true. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Returns elements from an observable sequence as long as a specified condition is true. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Filters the elements of an observable sequence based on a predicate. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a condition. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Filters the elements of an observable sequence based on a predicate by incorporating the element's index. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a conditio; the second parameter of the function represents the index of the source element. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a buffer. + Maximum element count of a buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Time shifts the observable sequence by the specified relative time duration. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence by the specified relative time duration, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence based on a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or is null. + + + + Time shifts the observable sequence based on a subscription delay and a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Sequence indicating the delay for the subscription to the source. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or or is null. + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Time-shifted sequence. + is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Returns an observable sequence that produces a value after each period. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Returns an observable sequence that produces a value after each period, using the specified scheduler to run timers and to send out observer messages. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + is null. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Samples the observable sequence at each interval. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Sampled observable sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the observable sequence at each interval, using the specified scheduler to run sampling timers. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Scheduler to run the sampling timer on. + Sampled observable sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the source observable sequence using a samper observable sequence producing sampling ticks. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + The type of the elements in the sampling sequence. + Source sequence to sample. + Sampling tick sequence. + Sampled observable sequence. + or is null. + + + + Skips elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements for the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements from the observable source sequence until the specified start time. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + An observable sequence with the elements skipped until the specified start time. + is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Skips elements from the observable source sequence until the specified start time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + Scheduler to run the timer on. + An observable sequence with the elements skipped until the specified start time. + or is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Takes elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Takes elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Returns elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified schedulers to run timers and to drain the collected elements. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + Scheduler to drain the collected elements. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Takes elements for the specified duration until the specified end time. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + An observable sequence with the elements taken until the specified end time. + is null. + + + + Takes elements for the specified duration until the specified end time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + Scheduler to run the timer on. + An observable sequence with the elements taken until the specified end time. + or is null. + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + The throttled sequence. + is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration, using the specified scheduler to run throttling timers. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + Scheduler to run the throttle timers on. + The throttled sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another value within a computed throttle duration. + + The type of the elements in the source sequence. + The type of the elements in the throttle sequences selected for each element in the source sequence. + Source sequence to throttle. + Selector function to retrieve a sequence indicating the throttle duration for each given element. + The throttled sequence. + or is null. + + This operator throttles the source sequence by holding on to each element for the duration denoted by . + If another element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this + whole process. For streams where the duration computed by applying the to each element overlaps with + the occurrence of the successor element, the resulting stream won't produce any elements. In order to reduce the volume of a stream whilst + guaranteeing the periodic production of elements, consider using the Observable.Sample set of operators. + + + + + Records the time interval between consecutive elements in an observable sequence. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + An observable sequence with time interval information on elements. + is null. + + + + Records the time interval between consecutive elements in an observable sequence, using the specified scheduler to compute time intervals. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + Scheduler used to compute time intervals. + An observable sequence with time interval information on elements. + or is null. + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + The source sequence with a TimeoutException in case of a timeout. + is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + The source sequence with a TimeoutException in case of a timeout. + is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or is null. + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or or is null. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + An observable sequence that produces a value after the due time has elapsed. + + + + Returns an observable sequence that produces a single value at the specified absolute due time. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + An observable sequence that produces a value at due time. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after due time has elapsed and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed, using the specified scheduler to run the timer. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after the due time has elapsed. + is null. + + + + Returns an observable sequence that produces a single value at the specified absolute due time, using the specified scheduler to run the timer. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value at due time. + is null. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run timers. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value after due time has elapsed and then each period. + is less than TimeSpan.Zero. + is null. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time, using the specified scheduler to run timers. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + is null. + + + + Timestamps each element in an observable sequence using the local system clock. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + An observable sequence with timestamp information on elements. + is null. + + + + Timestamp each element in an observable sequence using the clock of the specified scheduler. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + Scheduler used to compute timestamps. + An observable sequence with timestamp information on elements. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + The sequence of windows. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of windows. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Internal interface describing the LINQ to Events query language. + + + + + Base class for classes that expose an observable sequence as a well-known event pattern (sender, event arguments). + Contains functionality to maintain a map of event handler delegates to observable sequence subscriptions. Subclasses + should only add an event with custom add and remove methods calling into the base class's operations. + + The type of the sender that raises the event. + The type of the event data generated by the event. + + + + Creates a new event pattern source. + + Source sequence to expose as an event. + Delegate used to invoke the event for each element of the sequence. + or is null. + + + + Adds the specified event handler, causing a subscription to the underlying source. + + Event handler to add. The same delegate should be passed to the Remove operation in order to remove the event handler. + Invocation delegate to raise the event in the derived class. + or is null. + + + + Removes the specified event handler, causing a disposal of the corresponding subscription to the underlying source that was created during the Add operation. + + Event handler to remove. This should be the same delegate as one that was passed to the Add operation. + is null. + + + + Represents a .NET event invocation consisting of the weakly typed object that raised the event and the data that was generated by the event. + + The type of the event data generated by the event. + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + The type of the sender that raised the event. + The type of the event data generated by the event. + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Determines whether the current EventPattern<TSender, TEventArgs> object represents the same event as a specified EventPattern<TSender, TEventArgs> object. + + An object to compare to the current EventPattern<TSender, TEventArgs> object. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>. + + The System.Object to compare with the current EventPattern<TSender, TEventArgs>. + true if the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>; otherwise, false. + + + + Returns the hash code for the current EventPattern<TSender, TEventArgs> instance. + + A hash code for the current EventPattern<TSender, TEventArgs> instance. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent the same event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent a different event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects don't represent the same event; otherwise, false. + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Base class for historical schedulers, which are virtual time schedulers that use DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Base class for virtual time schedulers. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts the virtual time scheduler. + + + + + Stops the virtual time scheduler. + + + + + Advances the scheduler's clock to the specified time, running all work till that point. + + Absolute time to advance the scheduler's clock to. + is in the past. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan. + + Relative time to advance the scheduler's clock by. + is negative. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time. + + Relative time to advance the scheduler's clock by. + is negative. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Discovers scheduler services by interface type. The base class implementation supports + only the IStopwatchProvider service. To influence service discovery - such as adding + support for other scheduler services - derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Gets whether the scheduler is enabled to run work. + + + + + Gets the comparer used to compare absolute time values. + + + + + Gets the scheduler's absolute time clock value. + + + + + Gets the scheduler's notion of current time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial clock value. + + + + Creates a new historical scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Provides a virtual time scheduler that uses DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Base class for virtual time schedulers using a priority queue for scheduled items. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the resulting sequence, after transformation through the subject. + + + + Creates an observable that can be connected and disconnected from its source. + + Underlying observable source sequence that can be connected and disconnected from the wrapper. + Subject exposed by the connectable observable, receiving data from the underlying source sequence upon connection. + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable object used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Subscribes an observer to the observable sequence. No values from the underlying observable source will be received unless a connection was established through the Connect method. + + Observer that will receive values from the underlying observable source when the current ConnectableObservable instance is connected through a call to Connect. + Disposable used to unsubscribe from the observable sequence. + + + + Provides a set of static methods for creating subjects. + + + + + Creates a subject from the specified observer and observable. + + The type of the elements received by the observer. + The type of the elements produced by the observable sequence. + The observer used to send messages to the subject. + The observable used to subscribe to messages sent from the subject. + Subject implemented using the given observer and observable. + or is null. + + + + Synchronizes the messages sent to the subject. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Subject whose messages are synchronized. + is null. + + + + Synchronizes the messages sent to the subject and notifies observers on the specified scheduler. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Scheduler to notify observers on. + Subject whose messages are synchronized and whose observers are notified on the given scheduler. + or is null. + + + + Represents the result of an asynchronous operation. + The last value before the OnCompleted notification, or the error received through OnError, is sent to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject that can only receive one value and that value is cached for all future observations. + + + + + Notifies all subscribed observers about the end of the sequence, also causing the last received value to be sent out (if any). + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Sends a value to the subject. The last value received before successful termination will be sent to all subscribed and future observers. + + The value to store in the subject. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Gets an awaitable object for the current AsyncSubject. + + Object that can be awaited. + + + + Specifies a callback action that will be invoked when the subject completes. + + Callback action that will be invoked when the subject completes. + is null. + + + + Gets the last element of the subject, potentially blocking until the subject completes successfully or exceptionally. + + The last element of the subject. Throws an InvalidOperationException if no element was received. + The source sequence is empty. + + + + Indicates whether the subject has observers subscribed to it. + + + + + Gets whether the AsyncSubject has completed. + + + + + Represents a value that changes over time. + Observers can subscribe to the subject to receive the last (or initial) value and all subsequent notifications. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class which creates a subject that caches its last value and starts with the specified value. + + Initial value sent to observers when no other value has been received by the subject yet. + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject. + + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the specified exception. + + The exception to send to all currently subscribed observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all currently subscribed observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribes all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Abstract base class for join patterns. + + + + + Represents a join pattern over one observable sequence. + + The type of the elements in the first source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over two observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + + + + Creates a pattern that matches when all three observable sequences have an available element. + + The type of the elements in the third observable sequence. + Observable sequence to match with the two previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over three observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + + + + Creates a pattern that matches when all four observable sequences have an available element. + + The type of the elements in the fourth observable sequence. + Observable sequence to match with the three previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over four observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + + + + Creates a pattern that matches when all five observable sequences have an available element. + + The type of the elements in the fifth observable sequence. + Observable sequence to match with the four previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over five observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + + + + Creates a pattern that matches when all six observable sequences have an available element. + + The type of the elements in the sixth observable sequence. + Observable sequence to match with the five previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over six observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + + + + Creates a pattern that matches when all seven observable sequences have an available element. + + The type of the elements in the seventh observable sequence. + Observable sequence to match with the six previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over seven observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + + + + Creates a pattern that matches when all eight observable sequences have an available element. + + The type of the elements in the eighth observable sequence. + Observable sequence to match with the seven previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over eight observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + + + + Creates a pattern that matches when all nine observable sequences have an available element. + + The type of the elements in the ninth observable sequence. + Observable sequence to match with the eight previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over nine observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + + + + Creates a pattern that matches when all ten observable sequences have an available element. + + The type of the elements in the tenth observable sequence. + Observable sequence to match with the nine previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over ten observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + + + + Creates a pattern that matches when all eleven observable sequences have an available element. + + The type of the elements in the eleventh observable sequence. + Observable sequence to match with the ten previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over eleven observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + + + + Creates a pattern that matches when all twelve observable sequences have an available element. + + The type of the elements in the twelfth observable sequence. + Observable sequence to match with the eleven previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over twelve observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + + + + Creates a pattern that matches when all thirteen observable sequences have an available element. + + The type of the elements in the thirteenth observable sequence. + Observable sequence to match with the twelve previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over thirteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + + + + Creates a pattern that matches when all fourteen observable sequences have an available element. + + The type of the elements in the fourteenth observable sequence. + Observable sequence to match with the thirteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over fourteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + + + + Creates a pattern that matches when all fifteen observable sequences have an available element. + + The type of the elements in the fifteenth observable sequence. + Observable sequence to match with the fourteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over fifteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + + + + Creates a pattern that matches when all sixteen observable sequences have an available element. + + The type of the elements in the sixteenth observable sequence. + Observable sequence to match with the fifteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over sixteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents an execution plan for join patterns. + + The type of the results produced by the plan. + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed and future observers, subject to buffer trimming policies. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class with the specified buffer size, window and scheduler. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is less than zero. -or- is less than TimeSpan.Zero. + is null. + + + + Initializes a new instance of the class with the specified buffer size and window. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + is less than zero. -or- is less than TimeSpan.Zero. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified scheduler. + + Scheduler the observers are invoked on. + is null. + + + + Initializes a new instance of the class with the specified buffer size and scheduler. + + Maximum element count of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than zero. + + + + Initializes a new instance of the class with the specified buffer size. + + Maximum element count of the replay buffer. + is less than zero. + + + + Initializes a new instance of the class with the specified window and scheduler. + + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than TimeSpan.Zero. + + + + Initializes a new instance of the class with the specified window. + + Maximum time length of the replay buffer. + is less than TimeSpan.Zero. + + + + Notifies all subscribed and future observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Notifies all subscribed and future observers about the specified exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed and future observers about the end of the sequence. + + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribe all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + The System.Reactive.Threading.Tasks namespace contains helpers for the conversion between tasks and observable sequences. + + + + + Provides a set of static methods for converting tasks to observable sequences. + + + + + Returns an observable sequence that signals when the task completes. + + Task to convert to an observable sequence. + An observable sequence that produces a unit value when the task completes, or propagates the exception produced by the task. + is null. + If the specified task object supports cancellation, consider using instead. + + + + Returns an observable sequence that propagates the result of the task. + + The type of the result produced by the task. + Task to convert to an observable sequence. + An observable sequence that produces the task's result, or propagates the exception produced by the task. + is null. + If the specified task object supports cancellation, consider using instead. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + The state to use as the underlying task's AsyncState. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence. + The state to use as the underlying task's AsyncState. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Represents a value associated with time interval information. + The time interval can represent the time it took to produce the value, the interval relative to a previous value, the value's delivery time relative to a base, etc. + + The type of the value being annotated with time interval information. + + + + Constructs a time interval value. + + The value to be annotated with a time interval. + Time interval associated with the value. + + + + Determines whether the current TimeInterval<T> value has the same Value and Interval as a specified TimeInterval<T> value. + + An object to compare to the current TimeInterval<T> value. + true if both TimeInterval<T> values have the same Value and Interval; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has the same Value and Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values don't have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has a different Value or Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current TimeInterval<T>. + + The System.Object to compare with the current TimeInterval<T>. + true if the specified System.Object is equal to the current TimeInterval<T>; otherwise, false. + + + + Returns the hash code for the current TimeInterval<T> value. + + A hash code for the current TimeInterval<T> value. + + + + Returns a string representation of the current TimeInterval<T> value. + + String representation of the current TimeInterval<T> value. + + + + Gets the value. + + + + + Gets the interval. + + + + + Represents value with a timestamp on it. + The timestamp typically represents the time the value was received, using an IScheduler's clock to obtain the current time. + + The type of the value being timestamped. + + + + Constructs a timestamped value. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + + + + Determines whether the current Timestamped<T> value has the same Value and Timestamp as a specified Timestamped<T> value. + + An object to compare to the current Timestamped<T> value. + true if both Timestamped<T> values have the same Value and Timestamp; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has the same Value and Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values don't have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has a different Value or Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current Timestamped<T>. + + The System.Object to compare with the current Timestamped<T>. + true if the specified System.Object is equal to the current Timestamped<T>; otherwise, false. + + + + Returns the hash code for the current Timestamped<T> value. + + A hash code for the current Timestamped<T> value. + + + + Returns a string representation of the current Timestamped<T> value. + + String representation of the current Timestamped<T> value. + + + + Gets the value. + + + + + Gets the timestamp. + + + + + A helper class with a factory method for creating Timestamped<T> instances. + + + + + Creates an instance of a Timestamped<T>. This is syntactic sugar that uses type inference + to avoid specifying a type in a constructor call, which is very useful when using anonymous types. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + Creates a new timestamped value. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Could not find event '{0}' on object of type '{1}'.. + + + + + Looks up a localized string similar to Could not find event '{0}' on type '{1}'.. + + + + + Looks up a localized string similar to Add method should take 1 parameter.. + + + + + Looks up a localized string similar to The second parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Event is missing the add method.. + + + + + Looks up a localized string similar to Event is missing the remove method.. + + + + + Looks up a localized string similar to The event delegate must have a void return type.. + + + + + Looks up a localized string similar to The event delegate must have exactly two parameters.. + + + + + Looks up a localized string similar to Remove method should take 1 parameter.. + + + + + Looks up a localized string similar to The first parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Remove method of a WinRT event should take an EventRegistrationToken.. + + + + + Looks up a localized string similar to Sequence contains more than one element.. + + + + + Looks up a localized string similar to Sequence contains more than one matching element.. + + + + + Looks up a localized string similar to Sequence contains no elements.. + + + + + Looks up a localized string similar to Sequence contains no matching element.. + + + + + Looks up a localized string similar to {0} cannot be called when the scheduler is already running. Try using Sleep instead.. + + + + diff --git a/packages/Rx-Linq.2.1.30214.0/lib/Net45/System.Reactive.Linq.dll b/packages/Rx-Linq.2.1.30214.0/lib/Net45/System.Reactive.Linq.dll new file mode 100644 index 0000000000000000000000000000000000000000..6d89076a1aca277e8d01c8bcc75c20b5e972158d GIT binary patch literal 692296 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

    &-NffP3B*FwlhfDydM5ZIk zsO;@enu#O|(|{CX0-$R!LG>Ap%VaZEqwgph0cbQOY+*qrej5ms$mE+XxWQ$yRhr)H zffQP9i>l!lUfCgPXDC9%%p%6J2O)@?L|TL&yi^rCh#{?|#%wH}C5xLWe7=TOW1po% zi8Lt)X*d9)Hz)I%8QSX%Kl~#L9{>T{B7Cd_UP}>@lmPtI=nsj|Rx~D4KwH(Yh!k5@ z)rHNn4oFW*7RFlo3zOng62pZ_mVxo{F-evI$%*lCBVy76(-VXdqRd_?(J>LiM0p!a z3jeXtFH|FEFlyOVA;b~MIt3|JRgJ6~1vX2Hg@3_pRu@ZO_dvh+#AHEOjL>|bFfl1Q zKF&GS#?sc@FEKtcI!5Tsg!T?>R-me;N1`BBI3_-Elv{LCLX05Y7m}Jtge#)L4M+(~ z5+-Z2S(@T52*Q)2Q-zj3(Q%_$tVA{|)?Y}2xbA7m!Z@rniQ7L#n3&G>i4IE?K$wyw zjNm56bA@RMiNd5LZg_lbLX0qtD@+x}C36!J<6%gWqT@zzM?_p2z_D1$Y?hqAFj){C!(y4RSw?-M!xQ6^;vVpN#_v9O)EA*-?A~VDfGGw$?U0YaU_}IL6@rFx$v*M@nc<@$Dn+>>ccRLVJ5_ zfkR}3(81B#A>4r%5n)5|!vuD=VUB!?7hy-)I$8@I?ZRyw`F6HEp@V~CcsS2Gl4rxS z6^4b`T1N`Pc~Fl)NQFgMTU&?Q3Wd-Vo}E2E!qJ}RAQV8JgFqM-K}85C%AOy|w~cVH zkANDmA(4?0wvG78+#+tGhItZ<;!yIh*c03#F2!Sx%G1Au2 z&cWI)($PNLA=2K)-j)*DI@;TY+t~>DJO{@}8`}tBq>Wt|U%(IJ@onq{5#iQ$w*0V2 z+i+{jfwHxY5IDkE$H7=feLvRjX$df?VqvBUV*YQu|E1#%t3NB|`|(C&mWA zB8i42`+sBpuN-q=_zHyK8z8?4l+qfMC`j;)k8@887bYYF?+uJfj31K(tcb-rpQ7I% zL);ejo`OR1$ylXJoe3F8B!Tv$P{%QOW zUWk8S-;jQhk0>VPVB4g~ulfg_aR9ut~w+w~jzZ zoyPmW-~az3z$Sy=j>XDsUN_mZSs-Km07pD8_&+F9iFHy2Q}o|S8Q9cW16cvA5cqXx z`9sW`)sN*1X>a)TfH?l`m3i@%1uGQgGZ~g#swnJ1a#;YQ*CmrAfgAj?fvSL&2y~)Z zF)Sg_jAKQz;z@o7QYsK~1prNgd;u#N@Zupw|5eGD17S9_DH*V$0Y0JyN(uyrf_~Hg zY*=A92CO%L&t|y-y;%4sgj6!r!h${up{8(BS1QE0(C;)zAx08Ye-c3Zvr+(-$V!K} z55U7nOX+k9UD32u)0Y4sU#@Z4AB7iuKBbPwvGI0zo5a6Ii?ZtggAmf@2Pfw`VkJ4 z;-P#zJPB-1KWGuQjmrvzFq{1M=xhYhp!4gI;2L9n+DXS~c^Z|M!2sNBR3D6gufg@mak^yHmjL3g| zEV)3XC#jb!K^^B0J(K8Xj`Ix1J(%>hAA^bW2Ky>{4w%AO&VtqQXX7r}XD^l}^w|$+ z$3tx?@H~?xM)6PA42$JNo?~-5-#^WtJxdo-wkJGyob9n>rsLZClk&LU|5yKoD#7Tm zSS5Do%_iMcy)&iDJd3}-My=vV&{CX{P!wsd8xAO?p*+6D#d2=lqp3y*)FQm zQaZ9M%12JAiyT{qooz40mMQB_IZQz4bfqKqWU$!IoO>gRuqTesaI zZOGB76E0qkAMnbrEW3>fl`S)m%9hS5la_)nC2_2wIg1R6P1o;uec1sx2c#$!al_cM z(1di-BIyC(;2mI+FPjLT*6xh&a@____9^4BD#j_>?1M16m6Rhd|Pr zvKA+)tek&K+f*oJY@0Girf)w#e^FPYf6^5yo84Y=%-FIl>1?(dJYu$zR5qK<+O^C( zM*Va9g~AH0(rzaNVV{yatt*z(J~ui@d-Cu>D$!wac4fYe?bC1RAJq{|{q$vN>yBF0 z`-9ARlMC1L4GOPK?4CU6ecm#=fa5)1MDK`R96RtyT>U1KzDYF^qqi8=3UUisMlYg* za)x?O+fsMlw)VsoYDvJCj8XG*yKFZak$mA@+BQK!>8x>`&y0Aa{nwRU;m@3WyN{Q8 z@_OQiGiuwjCcOFl@cneJ-P4?>RLjrQd%ZWM{!2Kw(-OzmJp&yK0wY|u@OPz)0^DgtucaKU=PUvc76`mMl87tDnS%QMkDq&PKLaji(7m*U4oMZ*_&ow>*rX9?< z5X!;Anr8ueD9RF$s3D>@ve`1eln>Qgl%}NeyE9dc88fD(Duju@q@64|Wnh`Xlwq?v zFMI!d|3QBg* z-`f4mQ~hh(s|AzPYkb<2HMIVAb# zwRz{?!_#%YYF0wPfjR7oKD+mImL4-U?(r z$%5Df368|09Qk~{tu4cmY{W?_YxBRQW#4fmQ>r6OcwkTlajww`QJ|D|3vlPU2l#gF z<>2mWVNLb4v9Raa*zh`1#)v4*(QC0sj4tfA9PCv1!S@wgJ+FLpoE1M0E1rs)n)-t$#py$qW=lGBOJG{2@leu&w-pTu-@`Y5FFG3+_ z!tDNCFMiuGf90T2ecIf!4>G*YQaQZ-ab1?@#|HoP_sviC7b`DqvKUmnaRa%IVKoRg099TjJOX-z`YOz546b z*4gP_&)g%m^2oe8t?ClF=r;5DJ6}hrpPT$Ttdnl~wBwGJWLcuqliB_V-g>J@vxA3ibV-7kyLwCmHmZGjf`xi>6%S^BxIVJ!OQuMu89Qm--v5C)lno{;5W22u=>h3R zo!Y}X2Yc7wewkbPpx?*Ur7PQcJk5=Hx>{PPaa@MK{=!kqR;iWFST-XqxJ%mI@tclb z*_JTAZfH`#zBLyj{rWT<>oz;@-htl2MID3uc5?%#r+3wr4<0$lYybB@4LaGLWmHhq&UN5(#%)p5o~QOY1o-~+9=ye z02Rd>7tey~La*ZvP3zb{K0cZ23foLHXh8+ZLT=BL=;U-FH&K*>HIL8dIa>2U zZUR#cN%ArIPl|NE6P7k54i46)BKGOe59M-u%}Wi4>8@KFfAYl3$D_W^)l$Dz*EKmu zXS-Dy|LM1zfA{h=zL?0mW;;k}(((0N?>7xmm3{jZFW;NqXY>M3`Kyf`>lURHo>`OR zHt|x{wby%J*)2O3?0$X2I_FzvQFC=xE>BDv__FP+`bOJXiDk8^AqHdIbMhRt&L$0& z-8I6$c=@JitE<||UuPtDx|3=ZctevK{NY@2SmTLfAs#%xou-_67wSx6Cv~&-N9}!` z%lOVEr^+4V@`8N_W}9`EjX5VaA%?uRPA! zJ2@=gGA4L=+r`BvT2CA3bf8i(MEbml)eHw#GlWt@R>5Jjzsbl_(hx}So)+aGlw0-H zWMn|N&!;rx6q&O_8@7xrAq?Ar7$$|{R$~p%_q@sE*|$qWyRG8IuW;IP*@Ds*BWX&> zv@%cvO+*Tu;$2xin=v=l%Ir{=fu?isb>w{Md|N4C_Tc(ulpoF9yeUu0z09?&XMT@A zXKv#8o(NMr9A-9QY=I(128_*%@}S&AX<%#){}IN93kKHRXBzkd>v^3123#UJ~_^>G}CBUrL&dKu8LIy7v4?S zy<^LV^sU~B@4G+lIq~@IR&AqCEMLgA_@wN2Xy7S}yS>ltNqDeIr9yi7z*{>e_ZjqR zcCUpmU%z;MH{a04X~)3%4FSe^otI_n&Ac;9UjNk{-w#vDk3ZxrpYB_&dv03d?9QWO z7wCM@YY3YqeESY2WMS9KS4RpHcm*WOlq(lAjJI?Q^RVc2_j&Fz5?&!)|37ktcCE9AyZeebCj zf334|(|fMoMu#=*hV4+J)1^lhpXaGg=@+ZY@pT^8$!lR^&Fh%s2c9M@9W-Om_*une zx?a*l-k(`ILMeH<-7^cTw$=9&?KR%SZ*&@w{n39@v9*@aKy~sB^_vlI;!k^AIN$bB z`XQMu=Rcd*8BShYsq~p+>awo>L`}}oOQ3X#=g_a>9Di#%*a)qJgfQF?~Zo9#F`N1S#!GZ*p7CeR1=F2EOp)>FOor<3H>-mA)#HcUEcc*43v!J=1hM(CM;8T+76|M3Ig zrR4{V1CAGeazCSZcKC*~RlQ^?KCXzFIpUJpb&r6m{ImDWJSDvP-HTHxL*f5p996bzejZ*?&f2JQ{~oJD1oB5yU8$tt0; ziZeA^V!!3#%LM;+@giG2eVtZ$@3Q6Ve3F9R$a5@(|6{m*3(AKdMOheY^|_M|21~oy z-FUQR-I!~q)BE>jZ?sGvJv6ozXYJ{~#!lN|c|oIMN^IDUK~g7txg5WFH!@uA4BEXR zXujTUeRh83?zC4$XP; zuXifXxl5vQ_2UHRZ+S|by1$hKQyVVrX#2#sXyRepF2k4Zd$MP|a<8!$0uqg$Q^$9w z34@2S+bU_Qp1Z19`qpV@WYA^{s|O$R@=x|3_;69ete8qip9}BO_pND{5!UHN#ez;Y za$|JDjyW5|8fG^rA2r{7#&z?(k59*My}N8xvh5Dv!=sHgOj4Dd{HKf_;^C^fXY=N& zz9Xua^!k>WZj`yW4HfyYm&S0N>c#Di&bmJ8@@V%Puao8%F7q>eOgejY2pRHt;ENSE z=Pf$kHGXfFX|i1F=cz{f7GxhV4cxYIr1PZmRKb?Ga?XlW%Q>t8*^ z_*mrLMfwGBUz)SUhQZTz)EnK~T6H{pOIo1pg`Spvm9wgrr>)&wHYY{r%8UX|N_#8* zDuuYRp;J2UD|?Z9+^F`6LBC`3pL^eW&lbi{QXXF&U41|9@yfZUd7Zwg9v&Kexvy^d zwt&hun+y6_3YObHrvhzRL))YvF3Y-&;u@n!R+Q$!J%ddO zW6;4irIdN9lw@uj6b3~FWq2SA8ii`4Z200bRkre8o=$uRS)Bs)C@L#cf<`M|B9&0) zl-adKquC!BWXq{cOGauN5&xayEOJatblfPb9^j`j%G=GEXYc69cWkEo0p+SpHk-9| z_0uipLxbEljjgdhkytox>I|d9w|3q>)4z*XKy{K*_!pDCmpi_=JKbi5@ra^JY59|? zo&+s1$*i8$c&>-~(R`Y7^&jOQ-fF)oLve%g{LS2LrYh|_ zWSxK3HKjhwt0b~~S?H5KIg68ys=Ip+8S;GMrEMA2YfkMCtbKQA+o6Dr$~Hy1b6xtn z22H7~)qSRE)at~I#x32tv}=42H_Y#apt^5Ss9aB7Z}Tlx)`sdM$a94JxdT6Y}ib;EUWh4wky?ZH+P ztj#{OH#svXI<>AmyW?jnTS~X-0m|{RrCI?lGNHs%+q01yQaoU^OVI2 zc{a>a@jR5}sSzbVD*UZ&>}+^Lewd}@0fVexe0_U6TfdLZ_;aJ{7OopQ`8x>>r^x16 zH%vYoE=qr0Q@ZFwO;nV@r_UKLX0i?rDH(H|GCRC~SD!Q)-B6E{N*fkG$n(n&s!tKd z77sAmHR!_X0o?UmsSB5b<{S=Dl3O;S{jGJCGvAfHoww%QurkMuVcf2|es6Q+j7^;G ze;su?z~i`8hw_mt(#rU`W4?ZxW83-BkZ&i9I@uP-KV2F3*#FG68;z-3c6w)TdQ!92 zcK%ma^Bb-)uNNe3ne)UxWAb~m+i%|=d^F+Ciyifrb$_q1we}j)SZcGU_s@fT7XkM=UIy?I4@YR_R=JCo0?ca?{F{Ve_($s{wXMJl1G+GTsWHjWA_+YB+?U`Ce?Hw2Tz2GAg*K zFj$^Y`TbMN6H#zTl$GHgF4o`#DErBovuc;>7zed}-ZuTi+p6M~+7l*y89Q;>w6bg! zRF~`paeKLhB}(B=`X`l+LGF)<+}&(vR)!``__yd*%_tL)t3XF;*rZzlgFrJ&6c;Q4 zJjNVl5285*9-^pLA^xtS4RXLgg_bfITa)wqkE(++F&5qMwa3a0IKbE^M* zIX+b0mu0>1nfj#u*>!%kS2iu`{(i4QW{H%?+|EvLy4> zJ=e*BjYi>dAG|UQj$dE&#;<-`PWvgI2lP9;b$58V&2q=absyVMU2=OaP1-#_VRom5 z(@ajCcHHNqZ6&>M+w;ytDrda5>)!g#t4@#nDqK$U+nLJWTN$3Udg=1ltSg_po?pn` zoVe6h#yxG%Uwboa%tl2_dR>=X!a0z8&b`(p{#vlQg-Av>2N~UrR%moY(~?N7AT2GP z`92D435|=OhfEK@85=ECPrq^<9S$$>_wtZ!rV#Opi@4_}dp>(jTYLNVTVq!pPm!Aa zb8T;ncBA-&Bx0R{sVFu|;oJ+s9}CLff^r~A5rL?+pcENE1yKD(X;6xYY+paG;0N2( zk5wdttRT`oNr69>gi#olqI5P0$=OR>4Mq*y6rtw-{`~#J@x?`LKjt0u`*85?L9-9Z zqo4FMbw7WIPwcBaW``1&Zocq{D=D6O- z_g?I0zWggHK7Su={aP(jEq7V@YTf%4X0|WGQ9*-W|uw5+~`qjTNT}-@vcmMqE_n(rKgNt zb>to`y1q>@qu}E58#4R4F0IY}R5P(}npU4@PQ6uF3R79n9_G8<>T@HrqTFE5bE}A5 zYI7f{I-lA&skh0a={C0$?yVZ9; z+v3FGy_Ra4>&~b#A3wXUxbXP!6>r>fPH%m*Gc4wkRGZZq)JC(a(>g9sgAC+`52|ff zxhiklyK7br(-Q|x8f2@bJ_k9WSyqdA-h0Qb~^}m@q4}L(GQ7-U}Z^4L?`6AYhY{ z`N0iWR(Dws!tbRygO7*m$UcfpeaQDW(Xe{3R>AMgX1DFbE+4X#PFWlE`b6yOuEFJ6 zZ#;J0a)_vmi?B^wQ5LRdao%O-hr2iBRW1gnFZb^BK;^G8&X~VuIluUPx62T9!@dK} zDl!spX>{H0J^b>sXRgz8u8iF@HedHj_l;AAJ)G1pSLao^)!_P)ZWimUgAQ-+{*`}z zv$XTZO&ex7OgOhF)BLUP!0AS|9S=IjMNACXwNP!HwsG!>H@l?si{FPdob}%~WmdtS z{YJ?hL)w{bJ85d>(6Q99x80d>8)vN7GhVqm@~OaZW+a-QH6vl^t?zf1AyFbuSF)^T4rO?UAwfo_0Ij#<|xY zIGC7mEAc^xx_ut=4!`(YZ_u@z;-`JRsg-M|);%4%WW$#mRgrfN%*`76toB)-2i~1l za?Dn&96uuS{^YQan85TNwe)oRXxmT+S+umI4`({qn9*?q^(sQ?J3#W(`OwVBRdPM!GBWiM_ zXmK<8g=W8*^63Y=gQN#WqD5CJUWw~YO3q3r|Rbqi!taA|@b3 z*%fjVPP*vMn-0#}=xB@X)95%!I~rSZ^}l1NWcMBMDt~$Dt-y30%k!6$ zN3>s{Jg4>T@EP-Z%^80#y;aEpVTh%9_YVgXYhrW0{?+55((!KlJXbG$9epi)Uwhl- zbB76YOU4&@_zk$+YR0&8I(_tBJM}8^KU>u}>TY*=%T5dKJL@jLuvLG|EXO;KB96H^ zr)3zw=8RualAKfg=7foqN9VsMtM6X6TDH}KXHlP`EN7Q>?$LQvkaxJDVszY)(mC}x zZ}v}n?a}4tmu_eG+P;YExc=S-(`RRIyjI;X&ungKUsY%2R|=DA4G;3$-Dx;%aeC>ixHk;?lw_kDYN+C;thHsjq_rrvYuEL?hUn15LQLH%&Mx%qWhUw?R|RX*SJ z_NnD_&psa(-t+EI`Gp1D<;KX>$Zbq9)ci{z*xGRYh_1|Ebv=)&nmxZMw0b)CU3u`F z%dFaRkG+Fm&t0zA$4h-)rr}vur^6c;Ebrky#=!Q-xr&M<85!+AdCfLl``Obt^X=jf z`$lc=GxyGulr){EkL~BBx9jt*cC&F*%KZ(Wz7#!C&U_r*ZNnGpnT*fWy1JCu@afJq ziw64k+m|`0eR*1IzEQ@Do=O{gd|q{O*{}oUg$o9a9_Z`kzQ5P81*t=oGQCDMrY||L zH#T8D>%{?7+1GlsulXSMw$a>Y7A;QMAzMwY$@2Jbl zzB}gB!RH5f9vSEV9`p6?s8jPQjwZf3?Zo%)Izwd`cYETF*w@PSA4VJ;Ss3hWn`ial z-HH8A2k&_(Q$COz?|#K|THZCeRaE9dX^-o9^G)aJCbn+B>*4BeasGSnRerfVe@(tl z`BeA8vjwAPsfCOW-n4GoVdbZ@+*dmf)IT)WRYsU}J7B-|%we-V+U+{p+C}O3qainS z>=v783f)Q?kM*cd3-_E+Jb25I>4LKP?kCjOEp>XbC19%mYb&37)^2xXkNWWKM(Z{R zh99=zo^a+r%$2|Xp=3c9pHAzKzT})o6|*n>XMcQWd%nUU~R<@7?l+q1pt9^Li$H#MK;@6PFXas z;4{TA)yzQ&WCpur2bf|E>D<9e(rj?;Yp&^#;TCkeptpWOdYlm$APX8IYxQfE_AXpi zGIQm&`Ue56H`YkW^=CWxuWr|l1G^J>g_h{1;DuUy&`-%j1({OpH)UBnmt}4H$34JY zDGwX)0CTXjaC7%?_(Kn{vTW5uVE!Bp4tRq_;=E#3XClr^eYgAk_YvnQ#?i%|;_-R# z;;k(@y4Zp^4@nzLQse$D2M-gf1AXw&Z#sB1_Y=g!1_hJvM`2#lF?hAU%APT;CwJvO z{lc01_S3}ZS)-Bz)h{krVrA!jel{+uk9o-9gZBh~r*7{a*=1-$n*dW8o?%a2o!R=Q z6**JK38=vvDL1v3p@q4DuB|Th-Ql3Hxz~-Em9n+^erk{~EQ0a@|Kvd>gr6dXC$K7iar4#@(BLeB-KD8J(4Q z4Oe~Trf(}$uzi@OSM_M#DW?ZkZo5{#xgN218T$ZNac0`7FMIYMa~n2XYav^xnhyF>p~cVe-yiCP=Vg0i#VTN6R{U*Jys6WSoemJuNqeTA}SQ&}^ptZB{U*euFf zEQYeRct4e6{rY&*LaeJ_fEB#nE=Y+<{sSr2ubC8!FZ%tF6f1wfu)oTkBezO>WQ~?~ zUbM8_D1P&k6(`^F{yHOjXZ6=lgJQL*&3_+`JT|iK?SqE2y+>Cq?s)g(o@b*12Pt&v zpY5jcd1t_slW#&bCa0csap}3>dT`rs!5@dWwJq&1uut-fUh35w_Dwu8@s<7fAwBe7 z%}eh+-Ji9=L9OjutMn}4mDO8E)gL|m?sx_(z7OTrp}o_YXVS~(OdH&3&$dRH+X+kf zy-gbjY_R&e?cP-D-C-f~uMKi}^z!t)$dW1FMuttiak#hgbdx)dPqllG4qr6ZDE8pO zr4>$}CXSyovLtOq?77yHr@|W#htg~LGSI&;DnG4!GaJP267xDD{ zn|%|)2X|D`)6lEcDg)+a6eM+1xL<1VxcHW}rADW>`>g^^jow#R`d&5L zv2pdaIh$7YsyKE=yJz29`5!yaU)nm7I=?%a-={8o?Av*ht#pqXZ5X_D{dG5|xqhQB zm7hC2;BNHIK?iDXQu`ZE-tYTaW#6!Vj}{qdJ6P>G6C`W-LZ!^l_Ua2oQ@x9uC)gS& z?7C`q?R?0zo5_XV8nEHifDvG)Xw%WSQ%E+QW=22M{r|I^oPH67&!@oc8(hEX7g206 zX^qMMnVbG^_ouz~Z^PYZg_Z2K_Zpg>pPnW>vn`I@se7m59os9kKXUIL^nT*?d|(f` zMVn(&gZ00iesIjt{>q?lr_+7ru9PyBAFtWjr}pudalN|+WUO4%WGoYa2A<7mYxm$zz&7oLBL}ws z=Jv_5zq?lyKl#qQ;n`L0@9uhNsdPEf>b$Ra&vX3HT~1DpN-O@>+mx5^`og>0_pjvj zn!4FBzqm?oq(ZF9`kajxAGcjyZTk4Yx@(19ZfIKG@7!=jiZ|8!^nTAZkK2qhJhFU6 z$j}=$qa5d?J4US=8yu16Q@3k}T!?6Y0#TIRR>Ba_pj&tO@Rj-cFXo?YOnLp{)w3d} z&}N2!7PqVa;yWrJV1U0jzN12KDqsrW{i`;WpV0o^2Jk!Y8DbcK*I44Xi&T1EFuONu z-XzxjOkdWin(|3^H%2)vv@NUN+ROEVnbp&Xbk*@w8>7@$`Z+$033rTI+k0uRf!B+# ze?GdQEp<%J4Bu&)Y zSC(f>r-H_II60c%E&m^UE~x0J1PAmcGrn{imd3CR{t>CewA4o3j>uf|V*ba!l&_a% z{Y_=sjf{&Ofa>Z zQ=KU#h5#t-@rVd7eadAqkv6^P++%J#G1pF_tP~H-(PB3pa$qe}qQI$xB_*wOH?&+7 zmoIO&LyBG?i~js{#^?BR$2scnCbgM<)K{;Y;kUrLR~`SVh~;&eKJ#rawSI@c6+2`M zHY-h;z&Bog^=_He#Th*>+nbNreL-Q;#U-J#)EvtalWz0(S8g~peZJk$$c3|xS1RrG zWM^n*t%*4iE^m+&7}CwPvfuFFt22w|?cTYU%0I^1#fxv}Q~oimfh+u5b7Miew$)eQP#>yY;}Rl&Ju@Cet5 zSG0x(H!jHHJ_3A7#~*^_HvOm$CNJSQF>4g?(q17wKY}xI&cI1}!t*eK(-HJ3Sy#3L<^EXX{`c@-HJ{qVnXK2A=D(i{_0jXBJtYcKx z5i08-m92hf1zX*kRDO zr%m{btOI7YLtfrjo!&{$>^b%PM%;kg6FWXwu=mm|MU$Gmns@IrK2}u9`l`B@_4O5M z zvh~W69_6=pJwAVnCI8Uc!l~Q&_m8N3%UsZforBAIKR;(JVyZC}d^);0q9c>Kz TS3I?glsOi7_~3;bEY|-6={PW4 literal 0 HcmV?d00001 diff --git a/packages/Rx-Linq.2.1.30214.0/lib/NetCore45/System.Reactive.Linq.XML b/packages/Rx-Linq.2.1.30214.0/lib/NetCore45/System.Reactive.Linq.XML new file mode 100644 index 000000000..10215d636 --- /dev/null +++ b/packages/Rx-Linq.2.1.30214.0/lib/NetCore45/System.Reactive.Linq.XML @@ -0,0 +1,10565 @@ + + + + System.Reactive.Linq + + + + + The System.Reactive.Joins namespace contains classes used to express join patterns over observable sequences using fluent method syntax. + + + + + Provides a set of extension methods for virtual time scheduling. + + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Attribute applied to static classes providing expression tree forms of query methods, + mapping those to the corresponding methods for local query execution on the specified + target class type. + + + + + Creates a new mapping to the specified local execution query method implementation type. + + Type with query methods for local execution. + + + + Gets the type with the implementation of local query methods. + + + + + Provides a set of static methods for writing in-memory queries over observable sequences. + + + + + Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. + The loop can be quit prematurely by setting the specified cancellation token. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Cancellation token used to stop the loop. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. + The loop can be quit prematurely by setting the specified cancellation token. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Cancellation token used to stop the loop. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Uses to determine which source in to return, choosing if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Default source to select in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence on the specified scheduler if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Scheduler to generate an empty sequence on in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated after each repeated completed. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated upon the completion of an iteration through the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Concatenates the observable sequences obtained by running the for each element in the given enumerable . + + The type of the elements in the enumerable source sequence. + The type of the elements in the observable result sequence. + Enumerable source for which each element will be mapped onto an observable source that will be concatenated in the result sequence. + Function to select an observable source for each element in the . + The observable sequence obtained by concatenating the sources returned by for each element in the . + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, select the sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Sequence returned in case evaluates false. + if evaluates true; otherwise. + or or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + if evaluates true; an empty sequence otherwise. + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence generated on the specified scheduler. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Scheduler to generate an empty sequence on in case evaluates false. + if evaluates true; an empty sequence otherwise. + or or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated before each repeated is subscribed to. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated before subscription to the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the fourteenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the fourteenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Invokes the specified function asynchronously, surfacing the result through an observable sequence. + + The type of the result returned by the function. + Function to run asynchronously. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence + + The type of the result returned by the function. + Function to run asynchronously. + Scheduler to run the function on. + An observable sequence exposing the function's result value, or an exception. + or is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the asynchronous function, surfacing the result through an observable sequence. + + The type of the result returned by the asynchronous function. + Asynchronous function to run. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the asynchronous function, surfacing the result through an observable sequence. + The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information. + + The type of the result returned by the asynchronous function. + Asynchronous function to run. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + If any subscription to the resulting sequence is disposed, the CancellationToken is set. The observer associated to the disposed + subscription won't see the TaskCanceledException, but other observers will. You can protect against this using the Catch operator. + Be careful when handing out the resulting sequence because of this behavior. The most common use is to have a single subscription + to the resulting sequence, which controls the CancellationToken state. Alternatively, you can control subscription behavior using + multicast operators. + + + + + + + Invokes the action asynchronously, surfacing the result through an observable sequence. + + Action to run asynchronously. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the action asynchronously on the specified scheduler, surfacing the result through an observable sequence. + + Action to run asynchronously. + Scheduler to run the action on. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + or is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the asynchronous action, surfacing the result through an observable sequence. + + Asynchronous action to run. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the asynchronous action, surfacing the result through an observable sequence. + The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information. + + Asynchronous action to run. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + If any subscription to the resulting sequence is disposed, the CancellationToken is set. The observer associated to the disposed + subscription won't see the TaskCanceledException, but other observers will. You can protect against this using the Catch operator. + Be careful when handing out the resulting sequence because of this behavior. The most common use is to have a single subscription + to the resulting sequence, which controls the CancellationToken state. Alternatively, you can control subscription behavior using + multicast operators. + + + + + + + Converts to asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. + + The type of the result returned by the asynchronous function. + Asynchronous function to convert. + An observable sequence exposing the result of invoking the function, or an exception. + is null. + + + + Converts to asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. + The CancellationToken passed to the asynchronous function is tied to the observable sequence's subscription that triggered the function's invocation and can be used for best-effort cancellation. + + The type of the result returned by the asynchronous function. + Asynchronous function to convert. + An observable sequence exposing the result of invoking the function, or an exception. + is null. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous function will be signaled. + + + + Converts to asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. + + Asynchronous action to convert. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + + Converts to asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. + The CancellationToken passed to the asynchronous action is tied to the observable sequence's subscription that triggered the action's invocation and can be used for best-effort cancellation. + + Asynchronous action to convert. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous function will be signaled. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the sixteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the sixteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + The type of the sixteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + The type of the sixteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value, + and the specified result selector function is used to select the result value. + + The type of the elements in the source sequence. + The type of the accumulator value. + The type of the resulting value. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + A function to transform the final accumulator value into the result value. + An observable sequence containing a single element with the final accumulator value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to aggregate over. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether all elements of an observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains any elements. + + The type of the elements in the source sequence. + An observable sequence to check for non-emptiness. + An observable sequence containing a single element determining whether the source sequence contains any elements. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether any element of an observable sequence satisfies a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether any elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + (Asynchronous) The sum of the elements in the source sequence is larger than . + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using the default equality comparer. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using a specified System.Collections.Generic.IEqualityComparer<T>. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An equality comparer to compare elements. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the element at a specified index in a sequence. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence. + is null. + is less than zero. + (Asynchronous) is greater than or equal to the number of elements in the source sequence. + + + + Returns the element at a specified index in a sequence or a default value if the index is out of range. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence, or a default value if the index is outside the bounds of the source sequence. + is null. + is less than zero. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Determines whether an observable sequence is empty. + + The type of the elements in the source sequence. + An observable sequence to check for emptiness. + An observable sequence containing a single element determining whether the source sequence is empty. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + An observable sequence containing a single element with the maximum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + An observable sequence containing a single element with the minimum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the only element of an observable sequence, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence. + is null. + (Asynchronous) The source sequence contains more than one element. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence, or a default value if no such element exists. + is null. + (Asynchronous) The source sequence contains more than one element. + + + + Returns the only element of an observable sequence that matches the predicate, or a default value if no such element exists; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + (Asynchronous) The sequence contains more than one element that satisfies the condition in the predicate. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates an array from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get an array of elements for. + An observable sequence containing a single element with an array containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a list from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get a list of elements for. + An observable sequence containing a single element with a list containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes to the observable sequence, making it hot. + + The type of the elements in the source sequence. + Source sequence to await. + Object that can be awaited. + is null. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes and connects to the observable sequence, making it hot. + + The type of the elements in the source sequence. + Source sequence to await. + Object that can be awaited. + is null. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes to the observable sequence, making it hot. The supplied CancellationToken can be used to cancel the subscription. + + The type of the elements in the source sequence. + Source sequence to await. + Cancellation token. + Object that can be awaited. + is null. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes and connects to the observable sequence, making it hot. The supplied CancellationToken can be used to cancel the subscription and connection. + + The type of the elements in the source sequence. + Source sequence to await. + Cancellation token. + Object that can be awaited. + is null. + + + + Multicasts the source sequence notifications through the specified subject to the resulting connectable observable. Upon connection of the + connectable observable, the subject is subscribed to the source exactly one, and messages are forwarded to the observers registered with + the connectable observable. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be pushed into the specified subject. + Subject to push source elements into. + A connectable observable sequence that upon connection causes the source sequence to push results into the specified subject. + or is null. + + + + Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each + subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's + invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements produced by the intermediate subject. + The type of the elements in the result sequence. + Source sequence which will be multicasted in the specified selector function. + Factory function to create an intermediate subject through which the source sequence's elements will be multicast to the selector function. + Selector function which can use the multicasted source sequence subject to the policies enforced by the created subject. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Initial value received by observers upon subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + Initial value received by observers upon subscription. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will only receive the last notification of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will only receive the last notification of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + + The type of the elements in the source sequence. + Connectable observable sequence. + An observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all the notifications of the source. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + Subscribers will receive all the notifications of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Produces an enumerable sequence of consecutive (possibly empty) chunks of the source sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns consecutive (possibly empty) chunks upon each iteration. + is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create a new collector object. + Merges a sequence element with the current collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create the initial collector object. + Merges a sequence element with the current collector. + Factory to replace the current collector by a new collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or or is null. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Invokes an action for each element in the observable sequence, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Returns an enumerator that enumerates all values of the observable sequence. + + The type of the elements in the source sequence. + An observable sequence to get an enumerator for. + The enumerator that can be used to enumerate over the elements in the observable sequence. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Returns an enumerable sequence whose enumeration returns the latest observed element in the source observable sequence. + Enumerators on the resulting sequence will never produce the same element repeatedly, and will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns the last sampled element upon each iteration and subsequently blocks until the next element in the observable source sequence becomes available. + + + + Returns an enumerable sequence whose enumeration returns the most recently observed element in the source observable sequence, using the specified initial value in case no element has been sampled yet. + Enumerators on the resulting sequence never block and can produce the same element repeatedly. + + The type of the elements in the source sequence. + Source observable sequence. + Initial value that will be yielded by the enumerable sequence if no element has been sampled yet. + The enumerable sequence that returns the last sampled element upon each iteration. + is null. + + + + Returns an enumerable sequence whose enumeration blocks until the next element in the source observable sequence becomes available. + Enumerators on the resulting sequence will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that blocks upon each iteration until the next element in the observable source sequence becomes available. + is null. + + + + Returns the only element of an observable sequence, and throws an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence. + is null. + The source sequence contains more than one element. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and throws an exception if there is not exactly one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method throws an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence, or a default value if no such element exists. + is null. + The source sequence contains more than one element. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists; this method throws an exception if there is more than one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + The sequence contains more than one element that satisfies the condition in the predicate. + + + + + Waits for the observable sequence to complete and returns the last element of the sequence. + If the sequence terminates with an OnError notification, the exception is throw. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + This only invokes observer callbacks on a scheduler. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a scheduler, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + This only invokes observer callbacks on a synchronization context. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a synchronization context, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified scheduler. In order to invoke observer + callbacks on a scheduler, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified synchronization context. In order to invoke observer + callbacks on a synchronization context, use . + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently. + This overload is useful to "fix" an observable sequence that exhibits concurrent callbacks on individual observers, which is invalid behavior for the query processor. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + It's invalid behavior - according to the observer grammar - for a sequence to exhibit concurrent callbacks on a given observer. + This operator can be used to "fix" a source that doesn't conform to this rule. + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently, using the specified gate object. + This overload is useful when writing n-ary query operators, in order to prevent concurrent callbacks from different sources by synchronizing on a common gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Subscribes an observer to an enumerable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Disposable object that can be used to unsubscribe the observer from the enumerable + or is null. + + + + Subscribes an observer to an enumerable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Scheduler to perform the enumeration on. + Disposable object that can be used to unsubscribe the observer from the enumerable + or or is null. + + + + Converts an observable sequence to an enumerable sequence. + + The type of the elements in the source sequence. + An observable sequence to convert to an enumerable sequence. + The enumerable sequence containing the elements in the observable sequence. + is null. + + + + Exposes an observable sequence as an object with an Action-based .NET event. + + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with an Action<TSource>-based .NET event. + + The type of the elements in the source sequence. + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with a .NET event, conforming to the standard .NET event pattern. + + The type of the event data generated by the event. + Observable source sequence. + The event source object. + is null. + + + + Converts an enumerable sequence to an observable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + The observable sequence whose elements are pulled from the given enumerable sequence. + is null. + + + + Converts an enumerable sequence to an observable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + Scheduler to run the enumeration of the input sequence on. + The observable sequence whose elements are pulled from the given enumerable sequence. + or is null. + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to produce elements. + The observable sequence surfacing the elements produced by the asynchronous method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to produce elements. + The observable sequence surfacing the elements produced by the asynchronous method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Observable factory function to invoke for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger an invocation of the given observable factory function. + is null. + + + + Returns an observable sequence that starts the specified asynchronous factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Asynchronous factory function to start for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger the given asynchronous observable factory function to be started. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Returns an observable sequence that starts the specified cancellable asynchronous factory function whenever a new observer subscribes. + The CancellationToken passed to the asynchronous factory function is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Asynchronous factory function to start for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger the given asynchronous observable factory function to be started. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous observable factory function will be signaled. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence with no elements. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + An observable sequence with no elements. + is null. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + The generated sequence. + or or is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements, using the specified scheduler to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Scheduler on which to run the generator loop. + The generated sequence. + or or or is null. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence whose observers will never get called. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence whose observers will never get called. + + + + Generates an observable sequence of integral numbers within a specified range. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + + + + Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to send out observer messages. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + Scheduler to run the generator loop on. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + is null. + + + + Generates an observable sequence that repeats the given element infinitely. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + An observable sequence that repeats the given element infinitely. + + + + Generates an observable sequence that repeats the given element infinitely, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element infinitely. + is null. + + + + Generates an observable sequence that repeats the given element the specified number of times. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + + + + Generates an observable sequence that repeats the given element the specified number of times, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + is null. + + + + Returns an observable sequence that contains a single element. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + An observable sequence containing the single specified element. + + + + Returns an observable sequence that contains a single element, using the specified scheduler to send out observer messages. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + Scheduler to send the single element on. + An observable sequence containing the single specified element. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Factory function to obtain a resource object. + Factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. The resource is obtained and used through asynchronous methods. + The CancellationToken passed to the asynchronous methods is tied to the returned disposable subscription, allowing best-effort cancellation at any stage of the resource acquisition or usage. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Asynchronous factory function to obtain a resource object. + Asynchronous factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous resource factory and observable factory functions will be signaled. + + + + Creates a pattern that matches when both observable sequences have an available element. + + The type of the elements in the left sequence. + The type of the elements in the right sequence. + Observable sequence to match with the right sequence. + Observable sequence to match with the left sequence. + Pattern object that matches when both observable sequences have an available element. + or is null. + + + + Matches when the observable sequence has an available element and projects the element by invoking the selector function. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, returned by the selector function. + Observable sequence to apply the selector on. + Selector that will be invoked for elements in the source sequence. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + or is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results from matching several patterns. + is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results form matching several patterns. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that surfaces either of the given sequences, whichever reacted first. + or is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + A function invoked to define the boundaries of the produced buffers. A new buffer is started when the previous one is closed. + An observable sequence of buffers. + or is null. + + + + Projects each element of an observable sequence into zero or more buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequence indicating buffer opening events, also passed to the closing selector to obtain a sequence of buffer closing events. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + Observable sequence whose elements denote the creation of new buffers. + A function invoked to define the closing of each produced buffer. + An observable sequence of buffers. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer boundary events. + Source sequence to produce buffers over. + Sequence of buffer boundary markers. The current buffer is closed and a new buffer is opened upon receiving a boundary marker. + An observable sequence of buffers. + or is null. + + + + Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler. + + The type of the elements in the source sequence and sequences returned by the exception handler function. + The type of the exception to catch and handle. Needs to derive from . + Source sequence. + Exception handler function, producing another observable sequence. + An observable sequence containing the source sequence's elements, followed by the elements produced by the handler's resulting observable sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source sequence and handler sequence. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results when an error occurred in the first sequence. + An observable sequence containing the first sequence's elements, followed by the elements of the second sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Merges two observable sequences into one observable sequence by using the selector function whenever one of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke whenever either of the sources produces an element. + An observable sequence containing the result of combining elements of both sources using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Sixteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke whenever any of the sources produces an element. For efficiency, the input list is reused after the selector returns. Either aggregate or copy the values during the function call. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful termination of the first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that contains the elements of the first sequence, followed by those of the second the sequence. + or is null. + + + + Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all inner observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + An observable sequence that contains the elements of each observed inner sequence, in sequential order. + is null. + + + + Concatenates all task results, as long as the previous task terminated successfully. + + The type of the results produced by the tasks. + Observable sequence of tasks. + An observable sequence that contains the results of each task, in sequential order. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a concatenation operation using . + + + + Merges elements from all inner observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that merges the elements of the inner sequences. + is null. + + + + Merges results from all source tasks into a single observable sequence. + + The type of the results produced by the source tasks. + Observable sequence of tasks. + The observable sequence that merges the results of the source tasks. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a merge operation using . + + + + Merges elements from all inner observable sequences into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + Maximum number of inner observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the inner sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the observable sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences, and using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + is less than or equal to zero. + + + + Merges elements from two observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + The observable sequence that merges the elements of the given sequences. + or is null. + + + + Merges elements from two observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + Scheduler used to introduce concurrency for making subscriptions to the given sequences. + The observable sequence that merges the elements of the given sequences. + or or is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful or exceptional termination of the first. + + The type of the elements in the source sequences. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results after the first sequence terminates. + An observable sequence that concatenates the first and second sequence, even if the first sequence terminates exceptionally. + or is null. + + + + Concatenates all of the specified observable sequences, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Returns the elements from the source observable sequence only after the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of skip behavior. + Source sequence to propagate elements for. + Observable sequence that triggers propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation. + or is null. + + + + Switches between the inner observable sequences such that the resulting sequence always produces elements from the most recently received inner observable sequence. + Each time a new inner observable sequence is received, the previous inner observable sequence is unsubscribed from. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received. + is null. + + + + Switches between the tasks such that the resulting sequence always produces results from the most recently received task. + Each time a new task is received, the previous task's result is ignored. + + The type of the results produced by the source tasks. + Observable sequence of tasks. + The observable sequence that at any point in time produces the result of the most recent task that has been received. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a switch operation using . + + + + Returns the elements from the source observable sequence until the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of take behavior. + Source sequence to propagate elements for. + Observable sequence that terminates propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + A function invoked to define the boundaries of the produced windows. A new window is started when the previous one is closed. + An observable sequence of windows. + or is null. + + + + Projects each element of an observable sequence into zero or more windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequence indicating window opening events, also passed to the closing selector to obtain a sequence of window closing events. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + Observable sequence whose elements denote the creation of new windows. + A function invoked to define the closing of each produced window. + An observable sequence of windows. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window boundary events. + Source sequence to produce windows over. + Sequence of window boundary markers. The current window is closed and a new window is opened upon receiving a boundary marker. + An observable sequence of windows. + or is null. + + + + Merges two observable sequences into one observable sequence by combining their elements in a pairwise fashion. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Sixteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges an observable sequence and an enumerable sequence into one observable sequence by using the selector function. + + The type of the elements in the first observable source sequence. + The type of the elements in the second enumerable source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second enumerable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Hides the identity of an observable sequence. + + The type of the elements in the source sequence. + An observable sequence whose identity to hide. + An observable sequence that hides the identity of the source sequence. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Number of elements to skip between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than or equal to zero. + + + + Dematerializes the explicit notification values of an observable sequence as implicit notifications. + + The type of the elements materialized in the source sequence notification objects. + An observable sequence containing explicit notification values which have to be turned into implicit notifications. + An observable sequence exhibiting the behavior corresponding to the source sequence's notification values. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + An observable sequence only containing the distinct contiguous elements from the source sequence. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct contiguous elements from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + Equality comparer for computed key values. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or or is null. + + + + Invokes an action for each element in the observable sequence, and propagates all observer messages through the result sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or or is null. + + + + Invokes the observer's methods for each message in the source sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Observer whose methods to invoke as part of the source sequence's observation. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes a specified action after the source observable sequence terminates gracefully or exceptionally. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke after the source observable sequence terminates. + Source sequence with the action-invoking termination behavior applied. + or is null. + + + + Ignores all elements in an observable sequence leaving only the termination messages. + + The type of the elements in the source sequence. + Source sequence. + An empty observable sequence that signals termination, successful or exceptional, of the source sequence. + is null. + + + + Materializes the implicit notifications of an observable sequence as explicit notification values. + + The type of the elements in the source sequence. + An observable sequence to get notification values for. + An observable sequence containing the materialized notification values from the source sequence. + is null. + + + + Repeats the observable sequence indefinitely. + + The type of the elements in the source sequence. + Observable sequence to repeat. + The observable sequence producing the elements of the given sequence repeatedly and sequentially. + is null. + + + + Repeats the observable sequence a specified number of times. + + The type of the elements in the source sequence. + Observable sequence to repeat. + Number of times to repeat the sequence. + The observable sequence producing the elements of the given sequence repeatedly. + is null. + is less than zero. + + + + Repeats the source observable sequence until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + + + + Repeats the source observable sequence the specified number of times or until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + Number of times to repeat the sequence. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + is less than zero. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to accumulate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to accumulate over. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Bypasses a specified number of elements at the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to bypass at the end of the source sequence. + An observable sequence containing the source sequence elements except for the bypassed ones at the end. + is null. + is less than zero. + + This operator accumulates a queue with a length enough to store the first elements. As more elements are + received, elements are taken from the front of the queue and produced on the result sequence. This causes elements to be delayed. + + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Returns a specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a specified number of contiguous elements from the end of an observable sequence, using the specified scheduler to drain the queue. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + Scheduler used to drain the queue upon completion of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + or is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a list with the specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing a single list with the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements. Upon completion of the + source sequence, this buffer is produced on the result sequence. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + An observable sequence of windows. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Number of elements to skip between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than or equal to zero. + + + + Converts the elements of an observable sequence to the specified type. + + The type to convert the elements in the source sequence to. + The observable sequence that contains the elements to be converted. + An observable sequence that contains each element of the source sequence converted to the specified type. + is null. + + + + Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), whose default value will be taken if the sequence is empty. + The sequence to return a default value for if it is empty. + An observable sequence that contains the default value for the TSource type if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns the elements of the specified sequence or the specified value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), and the specified default value which will be taken if the sequence is empty. + The sequence to return the specified value for if it is empty. + The value to return if the sequence is empty. + An observable sequence that contains the specified default value if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns an observable sequence that contains only distinct elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + An observable sequence only containing the distinct elements from the source sequence. + is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct elements from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + Equality comparer for source elements. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Groups the elements of an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered. + + or or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or is null. + + + + Correlates the elements of two sequences based on overlapping durations, and groups the results. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any element of the left sequence with overlapping elements from the right observable sequence. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Correlates the elements of two sequences based on overlapping durations. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any two overlapping elements of the left and right observable sequences. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Filters the elements of an observable sequence based on the specified type. + + The type to filter the elements in the source sequence on. + The observable sequence that contains the elements to be filtered. + An observable sequence that contains elements from the input sequence of type TResult. + is null. + + + + Projects each element of an observable sequence into a new form. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of an observable sequence into a new form by incorporating the element's index. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the other sequence and the elements in the result sequence. + An observable sequence of elements to project. + An observable sequence to project each element from the source sequence onto. + An observable sequence whose elements are the result of projecting each source element onto the other sequence and merging all the resulting sequences together. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to a task and merges all of the task results into one observable sequence. + + The type of the elements in the source sequence. + The type of the result produced by the projected tasks and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of the tasks executed for each element of the input sequence. + This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + or is null. + + + + Projects each element of an observable sequence to a task with cancellation support and merges all of the task results into one observable sequence. + + The type of the elements in the source sequence. + The type of the result produced by the projected tasks and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of the tasks executed for each element of the input sequence. + This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to a task, invokes the result selector for the source element and the task result, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the results produced by the projected intermediate tasks. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate task results. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element. + or or is null. + This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + + + + Projects each element of an observable sequence to a task with cancellation support, invokes the result selector for the source element and the task result, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the results produced by the projected intermediate tasks. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate task results. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element. + or or is null. + This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element. + A transform function to apply when an error occurs in the source sequence. + A transform function to apply when the end of the source sequence is reached. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element; the second parameter represents the index of the source element. + A transform function to apply when an error occurs in the source sequence; the second parameter represents the index of the source element. + A transform function to apply when the end of the source sequence is reached; the second parameter represents the number of elements observed. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + The index of each source element is used in the projected form of that element. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Bypasses a specified number of elements in an observable sequence and then returns the remaining elements. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to skip before returning the remaining elements. + An observable sequence that contains the elements that occur after the specified index in the input sequence. + is null. + is less than zero. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Returns a specified number of contiguous elements from the start of an observable sequence. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + An observable sequence that contains the specified number of elements from the start of the input sequence. + is null. + is less than zero. + + + + Returns a specified number of contiguous elements from the start of an observable sequence, using the specified scheduler for the edge case of Take(0). + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + Scheduler used to produce an OnCompleted message in case count is set to 0. + An observable sequence that contains the specified number of elements from the start of the input sequence. + or is null. + is less than zero. + + + + Returns elements from an observable sequence as long as a specified condition is true. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Returns elements from an observable sequence as long as a specified condition is true. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Filters the elements of an observable sequence based on a predicate. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a condition. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Filters the elements of an observable sequence based on a predicate by incorporating the element's index. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a conditio; the second parameter of the function represents the index of the source element. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a buffer. + Maximum element count of a buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Time shifts the observable sequence by the specified relative time duration. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence by the specified relative time duration, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence based on a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or is null. + + + + Time shifts the observable sequence based on a subscription delay and a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Sequence indicating the delay for the subscription to the source. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or or is null. + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Time-shifted sequence. + is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Returns an observable sequence that produces a value after each period. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Returns an observable sequence that produces a value after each period, using the specified scheduler to run timers and to send out observer messages. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + is null. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Samples the observable sequence at each interval. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Sampled observable sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the observable sequence at each interval, using the specified scheduler to run sampling timers. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Scheduler to run the sampling timer on. + Sampled observable sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the source observable sequence using a samper observable sequence producing sampling ticks. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + The type of the elements in the sampling sequence. + Source sequence to sample. + Sampling tick sequence. + Sampled observable sequence. + or is null. + + + + Skips elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements for the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements from the observable source sequence until the specified start time. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + An observable sequence with the elements skipped until the specified start time. + is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Skips elements from the observable source sequence until the specified start time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + Scheduler to run the timer on. + An observable sequence with the elements skipped until the specified start time. + or is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Takes elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Takes elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Returns elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified schedulers to run timers and to drain the collected elements. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + Scheduler to drain the collected elements. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Takes elements for the specified duration until the specified end time. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + An observable sequence with the elements taken until the specified end time. + is null. + + + + Takes elements for the specified duration until the specified end time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + Scheduler to run the timer on. + An observable sequence with the elements taken until the specified end time. + or is null. + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + The throttled sequence. + is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration, using the specified scheduler to run throttling timers. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + Scheduler to run the throttle timers on. + The throttled sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another value within a computed throttle duration. + + The type of the elements in the source sequence. + The type of the elements in the throttle sequences selected for each element in the source sequence. + Source sequence to throttle. + Selector function to retrieve a sequence indicating the throttle duration for each given element. + The throttled sequence. + or is null. + + This operator throttles the source sequence by holding on to each element for the duration denoted by . + If another element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this + whole process. For streams where the duration computed by applying the to each element overlaps with + the occurrence of the successor element, the resulting stream won't produce any elements. In order to reduce the volume of a stream whilst + guaranteeing the periodic production of elements, consider using the Observable.Sample set of operators. + + + + + Records the time interval between consecutive elements in an observable sequence. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + An observable sequence with time interval information on elements. + is null. + + + + Records the time interval between consecutive elements in an observable sequence, using the specified scheduler to compute time intervals. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + Scheduler used to compute time intervals. + An observable sequence with time interval information on elements. + or is null. + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + The source sequence with a TimeoutException in case of a timeout. + is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + The source sequence with a TimeoutException in case of a timeout. + is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or is null. + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or or is null. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + An observable sequence that produces a value after the due time has elapsed. + + + + Returns an observable sequence that produces a single value at the specified absolute due time. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + An observable sequence that produces a value at due time. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after due time has elapsed and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed, using the specified scheduler to run the timer. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after the due time has elapsed. + is null. + + + + Returns an observable sequence that produces a single value at the specified absolute due time, using the specified scheduler to run the timer. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value at due time. + is null. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run timers. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value after due time has elapsed and then each period. + is less than TimeSpan.Zero. + is null. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time, using the specified scheduler to run timers. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + is null. + + + + Timestamps each element in an observable sequence using the local system clock. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + An observable sequence with timestamp information on elements. + is null. + + + + Timestamp each element in an observable sequence using the clock of the specified scheduler. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + Scheduler used to compute timestamps. + An observable sequence with timestamp information on elements. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + The sequence of windows. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of windows. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Internal interface describing the LINQ to Events query language. + + + + + Base class for classes that expose an observable sequence as a well-known event pattern (sender, event arguments). + Contains functionality to maintain a map of event handler delegates to observable sequence subscriptions. Subclasses + should only add an event with custom add and remove methods calling into the base class's operations. + + The type of the sender that raises the event. + The type of the event data generated by the event. + + + + Creates a new event pattern source. + + Source sequence to expose as an event. + Delegate used to invoke the event for each element of the sequence. + or is null. + + + + Adds the specified event handler, causing a subscription to the underlying source. + + Event handler to add. The same delegate should be passed to the Remove operation in order to remove the event handler. + Invocation delegate to raise the event in the derived class. + or is null. + + + + Removes the specified event handler, causing a disposal of the corresponding subscription to the underlying source that was created during the Add operation. + + Event handler to remove. This should be the same delegate as one that was passed to the Add operation. + is null. + + + + Represents a .NET event invocation consisting of the weakly typed object that raised the event and the data that was generated by the event. + + The type of the event data generated by the event. + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + The type of the sender that raised the event. + The type of the event data generated by the event. + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Determines whether the current EventPattern<TSender, TEventArgs> object represents the same event as a specified EventPattern<TSender, TEventArgs> object. + + An object to compare to the current EventPattern<TSender, TEventArgs> object. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>. + + The System.Object to compare with the current EventPattern<TSender, TEventArgs>. + true if the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>; otherwise, false. + + + + Returns the hash code for the current EventPattern<TSender, TEventArgs> instance. + + A hash code for the current EventPattern<TSender, TEventArgs> instance. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent the same event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent a different event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects don't represent the same event; otherwise, false. + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Base class for historical schedulers, which are virtual time schedulers that use DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Base class for virtual time schedulers. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts the virtual time scheduler. + + + + + Stops the virtual time scheduler. + + + + + Advances the scheduler's clock to the specified time, running all work till that point. + + Absolute time to advance the scheduler's clock to. + is in the past. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan. + + Relative time to advance the scheduler's clock by. + is negative. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time. + + Relative time to advance the scheduler's clock by. + is negative. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Discovers scheduler services by interface type. The base class implementation supports + only the IStopwatchProvider service. To influence service discovery - such as adding + support for other scheduler services - derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Gets whether the scheduler is enabled to run work. + + + + + Gets the comparer used to compare absolute time values. + + + + + Gets the scheduler's absolute time clock value. + + + + + Gets the scheduler's notion of current time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial clock value. + + + + Creates a new historical scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Provides a virtual time scheduler that uses DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Base class for virtual time schedulers using a priority queue for scheduled items. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the resulting sequence, after transformation through the subject. + + + + Creates an observable that can be connected and disconnected from its source. + + Underlying observable source sequence that can be connected and disconnected from the wrapper. + Subject exposed by the connectable observable, receiving data from the underlying source sequence upon connection. + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable object used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Subscribes an observer to the observable sequence. No values from the underlying observable source will be received unless a connection was established through the Connect method. + + Observer that will receive values from the underlying observable source when the current ConnectableObservable instance is connected through a call to Connect. + Disposable used to unsubscribe from the observable sequence. + + + + Provides a set of static methods for creating subjects. + + + + + Creates a subject from the specified observer and observable. + + The type of the elements received by the observer. + The type of the elements produced by the observable sequence. + The observer used to send messages to the subject. + The observable used to subscribe to messages sent from the subject. + Subject implemented using the given observer and observable. + or is null. + + + + Synchronizes the messages sent to the subject. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Subject whose messages are synchronized. + is null. + + + + Synchronizes the messages sent to the subject and notifies observers on the specified scheduler. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Scheduler to notify observers on. + Subject whose messages are synchronized and whose observers are notified on the given scheduler. + or is null. + + + + Represents the result of an asynchronous operation. + The last value before the OnCompleted notification, or the error received through OnError, is sent to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject that can only receive one value and that value is cached for all future observations. + + + + + Notifies all subscribed observers about the end of the sequence, also causing the last received value to be sent out (if any). + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Sends a value to the subject. The last value received before successful termination will be sent to all subscribed and future observers. + + The value to store in the subject. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Gets an awaitable object for the current AsyncSubject. + + Object that can be awaited. + + + + Specifies a callback action that will be invoked when the subject completes. + + Callback action that will be invoked when the subject completes. + is null. + + + + Gets the last element of the subject, potentially blocking until the subject completes successfully or exceptionally. + + The last element of the subject. Throws an InvalidOperationException if no element was received. + The source sequence is empty. + + + + Indicates whether the subject has observers subscribed to it. + + + + + Gets whether the AsyncSubject has completed. + + + + + Represents a value that changes over time. + Observers can subscribe to the subject to receive the last (or initial) value and all subsequent notifications. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class which creates a subject that caches its last value and starts with the specified value. + + Initial value sent to observers when no other value has been received by the subject yet. + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject. + + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the specified exception. + + The exception to send to all currently subscribed observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all currently subscribed observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribes all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Abstract base class for join patterns. + + + + + Represents a join pattern over one observable sequence. + + The type of the elements in the first source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over two observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + + + + Creates a pattern that matches when all three observable sequences have an available element. + + The type of the elements in the third observable sequence. + Observable sequence to match with the two previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over three observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + + + + Creates a pattern that matches when all four observable sequences have an available element. + + The type of the elements in the fourth observable sequence. + Observable sequence to match with the three previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over four observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + + + + Creates a pattern that matches when all five observable sequences have an available element. + + The type of the elements in the fifth observable sequence. + Observable sequence to match with the four previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over five observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + + + + Creates a pattern that matches when all six observable sequences have an available element. + + The type of the elements in the sixth observable sequence. + Observable sequence to match with the five previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over six observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + + + + Creates a pattern that matches when all seven observable sequences have an available element. + + The type of the elements in the seventh observable sequence. + Observable sequence to match with the six previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over seven observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + + + + Creates a pattern that matches when all eight observable sequences have an available element. + + The type of the elements in the eighth observable sequence. + Observable sequence to match with the seven previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over eight observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + + + + Creates a pattern that matches when all nine observable sequences have an available element. + + The type of the elements in the ninth observable sequence. + Observable sequence to match with the eight previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over nine observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + + + + Creates a pattern that matches when all ten observable sequences have an available element. + + The type of the elements in the tenth observable sequence. + Observable sequence to match with the nine previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over ten observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + + + + Creates a pattern that matches when all eleven observable sequences have an available element. + + The type of the elements in the eleventh observable sequence. + Observable sequence to match with the ten previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over eleven observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + + + + Creates a pattern that matches when all twelve observable sequences have an available element. + + The type of the elements in the twelfth observable sequence. + Observable sequence to match with the eleven previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over twelve observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + + + + Creates a pattern that matches when all thirteen observable sequences have an available element. + + The type of the elements in the thirteenth observable sequence. + Observable sequence to match with the twelve previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over thirteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + + + + Creates a pattern that matches when all fourteen observable sequences have an available element. + + The type of the elements in the fourteenth observable sequence. + Observable sequence to match with the thirteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over fourteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + + + + Creates a pattern that matches when all fifteen observable sequences have an available element. + + The type of the elements in the fifteenth observable sequence. + Observable sequence to match with the fourteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over fifteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + + + + Creates a pattern that matches when all sixteen observable sequences have an available element. + + The type of the elements in the sixteenth observable sequence. + Observable sequence to match with the fifteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over sixteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents an execution plan for join patterns. + + The type of the results produced by the plan. + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed and future observers, subject to buffer trimming policies. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class with the specified buffer size, window and scheduler. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is less than zero. -or- is less than TimeSpan.Zero. + is null. + + + + Initializes a new instance of the class with the specified buffer size and window. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + is less than zero. -or- is less than TimeSpan.Zero. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified scheduler. + + Scheduler the observers are invoked on. + is null. + + + + Initializes a new instance of the class with the specified buffer size and scheduler. + + Maximum element count of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than zero. + + + + Initializes a new instance of the class with the specified buffer size. + + Maximum element count of the replay buffer. + is less than zero. + + + + Initializes a new instance of the class with the specified window and scheduler. + + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than TimeSpan.Zero. + + + + Initializes a new instance of the class with the specified window. + + Maximum time length of the replay buffer. + is less than TimeSpan.Zero. + + + + Notifies all subscribed and future observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Notifies all subscribed and future observers about the specified exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed and future observers about the end of the sequence. + + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribe all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + The System.Reactive.Threading.Tasks namespace contains helpers for the conversion between tasks and observable sequences. + + + + + Provides a set of static methods for converting tasks to observable sequences. + + + + + Returns an observable sequence that signals when the task completes. + + Task to convert to an observable sequence. + An observable sequence that produces a unit value when the task completes, or propagates the exception produced by the task. + is null. + If the specified task object supports cancellation, consider using instead. + + + + Returns an observable sequence that propagates the result of the task. + + The type of the result produced by the task. + Task to convert to an observable sequence. + An observable sequence that produces the task's result, or propagates the exception produced by the task. + is null. + If the specified task object supports cancellation, consider using instead. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + The state to use as the underlying task's AsyncState. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence. + The state to use as the underlying task's AsyncState. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Represents a value associated with time interval information. + The time interval can represent the time it took to produce the value, the interval relative to a previous value, the value's delivery time relative to a base, etc. + + The type of the value being annotated with time interval information. + + + + Constructs a time interval value. + + The value to be annotated with a time interval. + Time interval associated with the value. + + + + Determines whether the current TimeInterval<T> value has the same Value and Interval as a specified TimeInterval<T> value. + + An object to compare to the current TimeInterval<T> value. + true if both TimeInterval<T> values have the same Value and Interval; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has the same Value and Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values don't have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has a different Value or Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current TimeInterval<T>. + + The System.Object to compare with the current TimeInterval<T>. + true if the specified System.Object is equal to the current TimeInterval<T>; otherwise, false. + + + + Returns the hash code for the current TimeInterval<T> value. + + A hash code for the current TimeInterval<T> value. + + + + Returns a string representation of the current TimeInterval<T> value. + + String representation of the current TimeInterval<T> value. + + + + Gets the value. + + + + + Gets the interval. + + + + + Represents value with a timestamp on it. + The timestamp typically represents the time the value was received, using an IScheduler's clock to obtain the current time. + + The type of the value being timestamped. + + + + Constructs a timestamped value. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + + + + Determines whether the current Timestamped<T> value has the same Value and Timestamp as a specified Timestamped<T> value. + + An object to compare to the current Timestamped<T> value. + true if both Timestamped<T> values have the same Value and Timestamp; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has the same Value and Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values don't have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has a different Value or Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current Timestamped<T>. + + The System.Object to compare with the current Timestamped<T>. + true if the specified System.Object is equal to the current Timestamped<T>; otherwise, false. + + + + Returns the hash code for the current Timestamped<T> value. + + A hash code for the current Timestamped<T> value. + + + + Returns a string representation of the current Timestamped<T> value. + + String representation of the current Timestamped<T> value. + + + + Gets the value. + + + + + Gets the timestamp. + + + + + A helper class with a factory method for creating Timestamped<T> instances. + + + + + Creates an instance of a Timestamped<T>. This is syntactic sugar that uses type inference + to avoid specifying a type in a constructor call, which is very useful when using anonymous types. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + Creates a new timestamped value. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Could not find event '{0}' on object of type '{1}'.. + + + + + Looks up a localized string similar to Could not find event '{0}' on type '{1}'.. + + + + + Looks up a localized string similar to Add method should take 1 parameter.. + + + + + Looks up a localized string similar to The second parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Event is missing the add method.. + + + + + Looks up a localized string similar to Event is missing the remove method.. + + + + + Looks up a localized string similar to The event delegate must have a void return type.. + + + + + Looks up a localized string similar to The event delegate must have exactly two parameters.. + + + + + Looks up a localized string similar to Remove method should take 1 parameter.. + + + + + Looks up a localized string similar to The first parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Remove method of a WinRT event should take an EventRegistrationToken.. + + + + + Looks up a localized string similar to Sequence contains more than one element.. + + + + + Looks up a localized string similar to Sequence contains more than one matching element.. + + + + + Looks up a localized string similar to Sequence contains no elements.. + + + + + Looks up a localized string similar to Sequence contains no matching element.. + + + + + Looks up a localized string similar to {0} cannot be called when the scheduler is already running. Try using Sleep instead.. + + + + diff --git a/packages/Rx-Linq.2.1.30214.0/lib/NetCore45/System.Reactive.Linq.dll b/packages/Rx-Linq.2.1.30214.0/lib/NetCore45/System.Reactive.Linq.dll new file mode 100644 index 0000000000000000000000000000000000000000..6d89076a1aca277e8d01c8bcc75c20b5e972158d GIT binary patch literal 692296 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

      &-NffP3B*FwlhfDydM5ZIk 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 z zvh~W69_6=pJwAVnCI8Uc!l~Q&_m8N3%UsZforBAIKR;(JVyZC}d^);0q9c>Kz TS3I?glsOi7_~3;bEY|-6={PW4 literal 0 HcmV?d00001 diff --git a/packages/Rx-Linq.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Linq.XML b/packages/Rx-Linq.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Linq.XML new file mode 100644 index 000000000..10215d636 --- /dev/null +++ b/packages/Rx-Linq.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Linq.XML @@ -0,0 +1,10565 @@ + + + + System.Reactive.Linq + + + + + The System.Reactive.Joins namespace contains classes used to express join patterns over observable sequences using fluent method syntax. + + + + + Provides a set of extension methods for virtual time scheduling. + + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Attribute applied to static classes providing expression tree forms of query methods, + mapping those to the corresponding methods for local query execution on the specified + target class type. + + + + + Creates a new mapping to the specified local execution query method implementation type. + + Type with query methods for local execution. + + + + Gets the type with the implementation of local query methods. + + + + + Provides a set of static methods for writing in-memory queries over observable sequences. + + + + + Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. + The loop can be quit prematurely by setting the specified cancellation token. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Cancellation token used to stop the loop. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. + The loop can be quit prematurely by setting the specified cancellation token. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Cancellation token used to stop the loop. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Uses to determine which source in to return, choosing if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Default source to select in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence on the specified scheduler if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Scheduler to generate an empty sequence on in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated after each repeated completed. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated upon the completion of an iteration through the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Concatenates the observable sequences obtained by running the for each element in the given enumerable . + + The type of the elements in the enumerable source sequence. + The type of the elements in the observable result sequence. + Enumerable source for which each element will be mapped onto an observable source that will be concatenated in the result sequence. + Function to select an observable source for each element in the . + The observable sequence obtained by concatenating the sources returned by for each element in the . + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, select the sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Sequence returned in case evaluates false. + if evaluates true; otherwise. + or or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + if evaluates true; an empty sequence otherwise. + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence generated on the specified scheduler. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Scheduler to generate an empty sequence on in case evaluates false. + if evaluates true; an empty sequence otherwise. + or or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated before each repeated is subscribed to. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated before subscription to the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the fourteenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the fourteenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Invokes the specified function asynchronously, surfacing the result through an observable sequence. + + The type of the result returned by the function. + Function to run asynchronously. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence + + The type of the result returned by the function. + Function to run asynchronously. + Scheduler to run the function on. + An observable sequence exposing the function's result value, or an exception. + or is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the asynchronous function, surfacing the result through an observable sequence. + + The type of the result returned by the asynchronous function. + Asynchronous function to run. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the asynchronous function, surfacing the result through an observable sequence. + The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information. + + The type of the result returned by the asynchronous function. + Asynchronous function to run. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + If any subscription to the resulting sequence is disposed, the CancellationToken is set. The observer associated to the disposed + subscription won't see the TaskCanceledException, but other observers will. You can protect against this using the Catch operator. + Be careful when handing out the resulting sequence because of this behavior. The most common use is to have a single subscription + to the resulting sequence, which controls the CancellationToken state. Alternatively, you can control subscription behavior using + multicast operators. + + + + + + + Invokes the action asynchronously, surfacing the result through an observable sequence. + + Action to run asynchronously. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the action asynchronously on the specified scheduler, surfacing the result through an observable sequence. + + Action to run asynchronously. + Scheduler to run the action on. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + or is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the asynchronous action, surfacing the result through an observable sequence. + + Asynchronous action to run. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the asynchronous action, surfacing the result through an observable sequence. + The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information. + + Asynchronous action to run. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + If any subscription to the resulting sequence is disposed, the CancellationToken is set. The observer associated to the disposed + subscription won't see the TaskCanceledException, but other observers will. You can protect against this using the Catch operator. + Be careful when handing out the resulting sequence because of this behavior. The most common use is to have a single subscription + to the resulting sequence, which controls the CancellationToken state. Alternatively, you can control subscription behavior using + multicast operators. + + + + + + + Converts to asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. + + The type of the result returned by the asynchronous function. + Asynchronous function to convert. + An observable sequence exposing the result of invoking the function, or an exception. + is null. + + + + Converts to asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. + The CancellationToken passed to the asynchronous function is tied to the observable sequence's subscription that triggered the function's invocation and can be used for best-effort cancellation. + + The type of the result returned by the asynchronous function. + Asynchronous function to convert. + An observable sequence exposing the result of invoking the function, or an exception. + is null. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous function will be signaled. + + + + Converts to asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. + + Asynchronous action to convert. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + + Converts to asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. + The CancellationToken passed to the asynchronous action is tied to the observable sequence's subscription that triggered the action's invocation and can be used for best-effort cancellation. + + Asynchronous action to convert. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous function will be signaled. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the sixteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the sixteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + The type of the sixteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + The type of the sixteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value, + and the specified result selector function is used to select the result value. + + The type of the elements in the source sequence. + The type of the accumulator value. + The type of the resulting value. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + A function to transform the final accumulator value into the result value. + An observable sequence containing a single element with the final accumulator value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to aggregate over. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether all elements of an observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains any elements. + + The type of the elements in the source sequence. + An observable sequence to check for non-emptiness. + An observable sequence containing a single element determining whether the source sequence contains any elements. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether any element of an observable sequence satisfies a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether any elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + (Asynchronous) The sum of the elements in the source sequence is larger than . + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using the default equality comparer. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using a specified System.Collections.Generic.IEqualityComparer<T>. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An equality comparer to compare elements. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the element at a specified index in a sequence. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence. + is null. + is less than zero. + (Asynchronous) is greater than or equal to the number of elements in the source sequence. + + + + Returns the element at a specified index in a sequence or a default value if the index is out of range. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence, or a default value if the index is outside the bounds of the source sequence. + is null. + is less than zero. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Determines whether an observable sequence is empty. + + The type of the elements in the source sequence. + An observable sequence to check for emptiness. + An observable sequence containing a single element determining whether the source sequence is empty. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + An observable sequence containing a single element with the maximum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + An observable sequence containing a single element with the minimum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the only element of an observable sequence, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence. + is null. + (Asynchronous) The source sequence contains more than one element. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence, or a default value if no such element exists. + is null. + (Asynchronous) The source sequence contains more than one element. + + + + Returns the only element of an observable sequence that matches the predicate, or a default value if no such element exists; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + (Asynchronous) The sequence contains more than one element that satisfies the condition in the predicate. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates an array from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get an array of elements for. + An observable sequence containing a single element with an array containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a list from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get a list of elements for. + An observable sequence containing a single element with a list containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes to the observable sequence, making it hot. + + The type of the elements in the source sequence. + Source sequence to await. + Object that can be awaited. + is null. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes and connects to the observable sequence, making it hot. + + The type of the elements in the source sequence. + Source sequence to await. + Object that can be awaited. + is null. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes to the observable sequence, making it hot. The supplied CancellationToken can be used to cancel the subscription. + + The type of the elements in the source sequence. + Source sequence to await. + Cancellation token. + Object that can be awaited. + is null. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes and connects to the observable sequence, making it hot. The supplied CancellationToken can be used to cancel the subscription and connection. + + The type of the elements in the source sequence. + Source sequence to await. + Cancellation token. + Object that can be awaited. + is null. + + + + Multicasts the source sequence notifications through the specified subject to the resulting connectable observable. Upon connection of the + connectable observable, the subject is subscribed to the source exactly one, and messages are forwarded to the observers registered with + the connectable observable. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be pushed into the specified subject. + Subject to push source elements into. + A connectable observable sequence that upon connection causes the source sequence to push results into the specified subject. + or is null. + + + + Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each + subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's + invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements produced by the intermediate subject. + The type of the elements in the result sequence. + Source sequence which will be multicasted in the specified selector function. + Factory function to create an intermediate subject through which the source sequence's elements will be multicast to the selector function. + Selector function which can use the multicasted source sequence subject to the policies enforced by the created subject. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Initial value received by observers upon subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + Initial value received by observers upon subscription. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will only receive the last notification of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will only receive the last notification of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + + The type of the elements in the source sequence. + Connectable observable sequence. + An observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all the notifications of the source. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + Subscribers will receive all the notifications of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Produces an enumerable sequence of consecutive (possibly empty) chunks of the source sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns consecutive (possibly empty) chunks upon each iteration. + is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create a new collector object. + Merges a sequence element with the current collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create the initial collector object. + Merges a sequence element with the current collector. + Factory to replace the current collector by a new collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or or is null. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Invokes an action for each element in the observable sequence, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Returns an enumerator that enumerates all values of the observable sequence. + + The type of the elements in the source sequence. + An observable sequence to get an enumerator for. + The enumerator that can be used to enumerate over the elements in the observable sequence. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Returns an enumerable sequence whose enumeration returns the latest observed element in the source observable sequence. + Enumerators on the resulting sequence will never produce the same element repeatedly, and will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns the last sampled element upon each iteration and subsequently blocks until the next element in the observable source sequence becomes available. + + + + Returns an enumerable sequence whose enumeration returns the most recently observed element in the source observable sequence, using the specified initial value in case no element has been sampled yet. + Enumerators on the resulting sequence never block and can produce the same element repeatedly. + + The type of the elements in the source sequence. + Source observable sequence. + Initial value that will be yielded by the enumerable sequence if no element has been sampled yet. + The enumerable sequence that returns the last sampled element upon each iteration. + is null. + + + + Returns an enumerable sequence whose enumeration blocks until the next element in the source observable sequence becomes available. + Enumerators on the resulting sequence will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that blocks upon each iteration until the next element in the observable source sequence becomes available. + is null. + + + + Returns the only element of an observable sequence, and throws an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence. + is null. + The source sequence contains more than one element. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and throws an exception if there is not exactly one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method throws an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence, or a default value if no such element exists. + is null. + The source sequence contains more than one element. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists; this method throws an exception if there is more than one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + The sequence contains more than one element that satisfies the condition in the predicate. + + + + + Waits for the observable sequence to complete and returns the last element of the sequence. + If the sequence terminates with an OnError notification, the exception is throw. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + This only invokes observer callbacks on a scheduler. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a scheduler, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + This only invokes observer callbacks on a synchronization context. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a synchronization context, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified scheduler. In order to invoke observer + callbacks on a scheduler, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified synchronization context. In order to invoke observer + callbacks on a synchronization context, use . + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently. + This overload is useful to "fix" an observable sequence that exhibits concurrent callbacks on individual observers, which is invalid behavior for the query processor. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + It's invalid behavior - according to the observer grammar - for a sequence to exhibit concurrent callbacks on a given observer. + This operator can be used to "fix" a source that doesn't conform to this rule. + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently, using the specified gate object. + This overload is useful when writing n-ary query operators, in order to prevent concurrent callbacks from different sources by synchronizing on a common gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Subscribes an observer to an enumerable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Disposable object that can be used to unsubscribe the observer from the enumerable + or is null. + + + + Subscribes an observer to an enumerable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Scheduler to perform the enumeration on. + Disposable object that can be used to unsubscribe the observer from the enumerable + or or is null. + + + + Converts an observable sequence to an enumerable sequence. + + The type of the elements in the source sequence. + An observable sequence to convert to an enumerable sequence. + The enumerable sequence containing the elements in the observable sequence. + is null. + + + + Exposes an observable sequence as an object with an Action-based .NET event. + + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with an Action<TSource>-based .NET event. + + The type of the elements in the source sequence. + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with a .NET event, conforming to the standard .NET event pattern. + + The type of the event data generated by the event. + Observable source sequence. + The event source object. + is null. + + + + Converts an enumerable sequence to an observable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + The observable sequence whose elements are pulled from the given enumerable sequence. + is null. + + + + Converts an enumerable sequence to an observable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + Scheduler to run the enumeration of the input sequence on. + The observable sequence whose elements are pulled from the given enumerable sequence. + or is null. + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to produce elements. + The observable sequence surfacing the elements produced by the asynchronous method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to produce elements. + The observable sequence surfacing the elements produced by the asynchronous method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Observable factory function to invoke for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger an invocation of the given observable factory function. + is null. + + + + Returns an observable sequence that starts the specified asynchronous factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Asynchronous factory function to start for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger the given asynchronous observable factory function to be started. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Returns an observable sequence that starts the specified cancellable asynchronous factory function whenever a new observer subscribes. + The CancellationToken passed to the asynchronous factory function is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Asynchronous factory function to start for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger the given asynchronous observable factory function to be started. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous observable factory function will be signaled. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence with no elements. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + An observable sequence with no elements. + is null. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + The generated sequence. + or or is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements, using the specified scheduler to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Scheduler on which to run the generator loop. + The generated sequence. + or or or is null. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence whose observers will never get called. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence whose observers will never get called. + + + + Generates an observable sequence of integral numbers within a specified range. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + + + + Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to send out observer messages. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + Scheduler to run the generator loop on. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + is null. + + + + Generates an observable sequence that repeats the given element infinitely. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + An observable sequence that repeats the given element infinitely. + + + + Generates an observable sequence that repeats the given element infinitely, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element infinitely. + is null. + + + + Generates an observable sequence that repeats the given element the specified number of times. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + + + + Generates an observable sequence that repeats the given element the specified number of times, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + is null. + + + + Returns an observable sequence that contains a single element. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + An observable sequence containing the single specified element. + + + + Returns an observable sequence that contains a single element, using the specified scheduler to send out observer messages. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + Scheduler to send the single element on. + An observable sequence containing the single specified element. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Factory function to obtain a resource object. + Factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. The resource is obtained and used through asynchronous methods. + The CancellationToken passed to the asynchronous methods is tied to the returned disposable subscription, allowing best-effort cancellation at any stage of the resource acquisition or usage. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Asynchronous factory function to obtain a resource object. + Asynchronous factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous resource factory and observable factory functions will be signaled. + + + + Creates a pattern that matches when both observable sequences have an available element. + + The type of the elements in the left sequence. + The type of the elements in the right sequence. + Observable sequence to match with the right sequence. + Observable sequence to match with the left sequence. + Pattern object that matches when both observable sequences have an available element. + or is null. + + + + Matches when the observable sequence has an available element and projects the element by invoking the selector function. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, returned by the selector function. + Observable sequence to apply the selector on. + Selector that will be invoked for elements in the source sequence. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + or is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results from matching several patterns. + is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results form matching several patterns. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that surfaces either of the given sequences, whichever reacted first. + or is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + A function invoked to define the boundaries of the produced buffers. A new buffer is started when the previous one is closed. + An observable sequence of buffers. + or is null. + + + + Projects each element of an observable sequence into zero or more buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequence indicating buffer opening events, also passed to the closing selector to obtain a sequence of buffer closing events. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + Observable sequence whose elements denote the creation of new buffers. + A function invoked to define the closing of each produced buffer. + An observable sequence of buffers. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer boundary events. + Source sequence to produce buffers over. + Sequence of buffer boundary markers. The current buffer is closed and a new buffer is opened upon receiving a boundary marker. + An observable sequence of buffers. + or is null. + + + + Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler. + + The type of the elements in the source sequence and sequences returned by the exception handler function. + The type of the exception to catch and handle. Needs to derive from . + Source sequence. + Exception handler function, producing another observable sequence. + An observable sequence containing the source sequence's elements, followed by the elements produced by the handler's resulting observable sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source sequence and handler sequence. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results when an error occurred in the first sequence. + An observable sequence containing the first sequence's elements, followed by the elements of the second sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Merges two observable sequences into one observable sequence by using the selector function whenever one of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke whenever either of the sources produces an element. + An observable sequence containing the result of combining elements of both sources using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Sixteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke whenever any of the sources produces an element. For efficiency, the input list is reused after the selector returns. Either aggregate or copy the values during the function call. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful termination of the first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that contains the elements of the first sequence, followed by those of the second the sequence. + or is null. + + + + Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all inner observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + An observable sequence that contains the elements of each observed inner sequence, in sequential order. + is null. + + + + Concatenates all task results, as long as the previous task terminated successfully. + + The type of the results produced by the tasks. + Observable sequence of tasks. + An observable sequence that contains the results of each task, in sequential order. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a concatenation operation using . + + + + Merges elements from all inner observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that merges the elements of the inner sequences. + is null. + + + + Merges results from all source tasks into a single observable sequence. + + The type of the results produced by the source tasks. + Observable sequence of tasks. + The observable sequence that merges the results of the source tasks. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a merge operation using . + + + + Merges elements from all inner observable sequences into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + Maximum number of inner observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the inner sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the observable sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences, and using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + is less than or equal to zero. + + + + Merges elements from two observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + The observable sequence that merges the elements of the given sequences. + or is null. + + + + Merges elements from two observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + Scheduler used to introduce concurrency for making subscriptions to the given sequences. + The observable sequence that merges the elements of the given sequences. + or or is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful or exceptional termination of the first. + + The type of the elements in the source sequences. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results after the first sequence terminates. + An observable sequence that concatenates the first and second sequence, even if the first sequence terminates exceptionally. + or is null. + + + + Concatenates all of the specified observable sequences, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Returns the elements from the source observable sequence only after the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of skip behavior. + Source sequence to propagate elements for. + Observable sequence that triggers propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation. + or is null. + + + + Switches between the inner observable sequences such that the resulting sequence always produces elements from the most recently received inner observable sequence. + Each time a new inner observable sequence is received, the previous inner observable sequence is unsubscribed from. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received. + is null. + + + + Switches between the tasks such that the resulting sequence always produces results from the most recently received task. + Each time a new task is received, the previous task's result is ignored. + + The type of the results produced by the source tasks. + Observable sequence of tasks. + The observable sequence that at any point in time produces the result of the most recent task that has been received. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a switch operation using . + + + + Returns the elements from the source observable sequence until the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of take behavior. + Source sequence to propagate elements for. + Observable sequence that terminates propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + A function invoked to define the boundaries of the produced windows. A new window is started when the previous one is closed. + An observable sequence of windows. + or is null. + + + + Projects each element of an observable sequence into zero or more windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequence indicating window opening events, also passed to the closing selector to obtain a sequence of window closing events. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + Observable sequence whose elements denote the creation of new windows. + A function invoked to define the closing of each produced window. + An observable sequence of windows. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window boundary events. + Source sequence to produce windows over. + Sequence of window boundary markers. The current window is closed and a new window is opened upon receiving a boundary marker. + An observable sequence of windows. + or is null. + + + + Merges two observable sequences into one observable sequence by combining their elements in a pairwise fashion. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Sixteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges an observable sequence and an enumerable sequence into one observable sequence by using the selector function. + + The type of the elements in the first observable source sequence. + The type of the elements in the second enumerable source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second enumerable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Hides the identity of an observable sequence. + + The type of the elements in the source sequence. + An observable sequence whose identity to hide. + An observable sequence that hides the identity of the source sequence. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Number of elements to skip between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than or equal to zero. + + + + Dematerializes the explicit notification values of an observable sequence as implicit notifications. + + The type of the elements materialized in the source sequence notification objects. + An observable sequence containing explicit notification values which have to be turned into implicit notifications. + An observable sequence exhibiting the behavior corresponding to the source sequence's notification values. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + An observable sequence only containing the distinct contiguous elements from the source sequence. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct contiguous elements from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + Equality comparer for computed key values. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or or is null. + + + + Invokes an action for each element in the observable sequence, and propagates all observer messages through the result sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or or is null. + + + + Invokes the observer's methods for each message in the source sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Observer whose methods to invoke as part of the source sequence's observation. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes a specified action after the source observable sequence terminates gracefully or exceptionally. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke after the source observable sequence terminates. + Source sequence with the action-invoking termination behavior applied. + or is null. + + + + Ignores all elements in an observable sequence leaving only the termination messages. + + The type of the elements in the source sequence. + Source sequence. + An empty observable sequence that signals termination, successful or exceptional, of the source sequence. + is null. + + + + Materializes the implicit notifications of an observable sequence as explicit notification values. + + The type of the elements in the source sequence. + An observable sequence to get notification values for. + An observable sequence containing the materialized notification values from the source sequence. + is null. + + + + Repeats the observable sequence indefinitely. + + The type of the elements in the source sequence. + Observable sequence to repeat. + The observable sequence producing the elements of the given sequence repeatedly and sequentially. + is null. + + + + Repeats the observable sequence a specified number of times. + + The type of the elements in the source sequence. + Observable sequence to repeat. + Number of times to repeat the sequence. + The observable sequence producing the elements of the given sequence repeatedly. + is null. + is less than zero. + + + + Repeats the source observable sequence until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + + + + Repeats the source observable sequence the specified number of times or until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + Number of times to repeat the sequence. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + is less than zero. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to accumulate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to accumulate over. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Bypasses a specified number of elements at the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to bypass at the end of the source sequence. + An observable sequence containing the source sequence elements except for the bypassed ones at the end. + is null. + is less than zero. + + This operator accumulates a queue with a length enough to store the first elements. As more elements are + received, elements are taken from the front of the queue and produced on the result sequence. This causes elements to be delayed. + + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Returns a specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a specified number of contiguous elements from the end of an observable sequence, using the specified scheduler to drain the queue. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + Scheduler used to drain the queue upon completion of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + or is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a list with the specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing a single list with the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements. Upon completion of the + source sequence, this buffer is produced on the result sequence. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + An observable sequence of windows. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Number of elements to skip between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than or equal to zero. + + + + Converts the elements of an observable sequence to the specified type. + + The type to convert the elements in the source sequence to. + The observable sequence that contains the elements to be converted. + An observable sequence that contains each element of the source sequence converted to the specified type. + is null. + + + + Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), whose default value will be taken if the sequence is empty. + The sequence to return a default value for if it is empty. + An observable sequence that contains the default value for the TSource type if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns the elements of the specified sequence or the specified value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), and the specified default value which will be taken if the sequence is empty. + The sequence to return the specified value for if it is empty. + The value to return if the sequence is empty. + An observable sequence that contains the specified default value if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns an observable sequence that contains only distinct elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + An observable sequence only containing the distinct elements from the source sequence. + is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct elements from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + Equality comparer for source elements. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Groups the elements of an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered. + + or or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or is null. + + + + Correlates the elements of two sequences based on overlapping durations, and groups the results. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any element of the left sequence with overlapping elements from the right observable sequence. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Correlates the elements of two sequences based on overlapping durations. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any two overlapping elements of the left and right observable sequences. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Filters the elements of an observable sequence based on the specified type. + + The type to filter the elements in the source sequence on. + The observable sequence that contains the elements to be filtered. + An observable sequence that contains elements from the input sequence of type TResult. + is null. + + + + Projects each element of an observable sequence into a new form. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of an observable sequence into a new form by incorporating the element's index. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the other sequence and the elements in the result sequence. + An observable sequence of elements to project. + An observable sequence to project each element from the source sequence onto. + An observable sequence whose elements are the result of projecting each source element onto the other sequence and merging all the resulting sequences together. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to a task and merges all of the task results into one observable sequence. + + The type of the elements in the source sequence. + The type of the result produced by the projected tasks and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of the tasks executed for each element of the input sequence. + This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + or is null. + + + + Projects each element of an observable sequence to a task with cancellation support and merges all of the task results into one observable sequence. + + The type of the elements in the source sequence. + The type of the result produced by the projected tasks and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of the tasks executed for each element of the input sequence. + This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to a task, invokes the result selector for the source element and the task result, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the results produced by the projected intermediate tasks. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate task results. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element. + or or is null. + This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + + + + Projects each element of an observable sequence to a task with cancellation support, invokes the result selector for the source element and the task result, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the results produced by the projected intermediate tasks. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate task results. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element. + or or is null. + This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element. + A transform function to apply when an error occurs in the source sequence. + A transform function to apply when the end of the source sequence is reached. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element; the second parameter represents the index of the source element. + A transform function to apply when an error occurs in the source sequence; the second parameter represents the index of the source element. + A transform function to apply when the end of the source sequence is reached; the second parameter represents the number of elements observed. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + The index of each source element is used in the projected form of that element. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Bypasses a specified number of elements in an observable sequence and then returns the remaining elements. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to skip before returning the remaining elements. + An observable sequence that contains the elements that occur after the specified index in the input sequence. + is null. + is less than zero. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Returns a specified number of contiguous elements from the start of an observable sequence. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + An observable sequence that contains the specified number of elements from the start of the input sequence. + is null. + is less than zero. + + + + Returns a specified number of contiguous elements from the start of an observable sequence, using the specified scheduler for the edge case of Take(0). + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + Scheduler used to produce an OnCompleted message in case count is set to 0. + An observable sequence that contains the specified number of elements from the start of the input sequence. + or is null. + is less than zero. + + + + Returns elements from an observable sequence as long as a specified condition is true. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Returns elements from an observable sequence as long as a specified condition is true. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Filters the elements of an observable sequence based on a predicate. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a condition. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Filters the elements of an observable sequence based on a predicate by incorporating the element's index. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a conditio; the second parameter of the function represents the index of the source element. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a buffer. + Maximum element count of a buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Time shifts the observable sequence by the specified relative time duration. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence by the specified relative time duration, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence based on a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or is null. + + + + Time shifts the observable sequence based on a subscription delay and a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Sequence indicating the delay for the subscription to the source. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or or is null. + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Time-shifted sequence. + is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Returns an observable sequence that produces a value after each period. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Returns an observable sequence that produces a value after each period, using the specified scheduler to run timers and to send out observer messages. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + is null. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Samples the observable sequence at each interval. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Sampled observable sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the observable sequence at each interval, using the specified scheduler to run sampling timers. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Scheduler to run the sampling timer on. + Sampled observable sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the source observable sequence using a samper observable sequence producing sampling ticks. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + The type of the elements in the sampling sequence. + Source sequence to sample. + Sampling tick sequence. + Sampled observable sequence. + or is null. + + + + Skips elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements for the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements from the observable source sequence until the specified start time. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + An observable sequence with the elements skipped until the specified start time. + is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Skips elements from the observable source sequence until the specified start time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + Scheduler to run the timer on. + An observable sequence with the elements skipped until the specified start time. + or is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Takes elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Takes elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Returns elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified schedulers to run timers and to drain the collected elements. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + Scheduler to drain the collected elements. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Takes elements for the specified duration until the specified end time. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + An observable sequence with the elements taken until the specified end time. + is null. + + + + Takes elements for the specified duration until the specified end time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + Scheduler to run the timer on. + An observable sequence with the elements taken until the specified end time. + or is null. + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + The throttled sequence. + is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration, using the specified scheduler to run throttling timers. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + Scheduler to run the throttle timers on. + The throttled sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another value within a computed throttle duration. + + The type of the elements in the source sequence. + The type of the elements in the throttle sequences selected for each element in the source sequence. + Source sequence to throttle. + Selector function to retrieve a sequence indicating the throttle duration for each given element. + The throttled sequence. + or is null. + + This operator throttles the source sequence by holding on to each element for the duration denoted by . + If another element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this + whole process. For streams where the duration computed by applying the to each element overlaps with + the occurrence of the successor element, the resulting stream won't produce any elements. In order to reduce the volume of a stream whilst + guaranteeing the periodic production of elements, consider using the Observable.Sample set of operators. + + + + + Records the time interval between consecutive elements in an observable sequence. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + An observable sequence with time interval information on elements. + is null. + + + + Records the time interval between consecutive elements in an observable sequence, using the specified scheduler to compute time intervals. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + Scheduler used to compute time intervals. + An observable sequence with time interval information on elements. + or is null. + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + The source sequence with a TimeoutException in case of a timeout. + is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + The source sequence with a TimeoutException in case of a timeout. + is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or is null. + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or or is null. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + An observable sequence that produces a value after the due time has elapsed. + + + + Returns an observable sequence that produces a single value at the specified absolute due time. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + An observable sequence that produces a value at due time. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after due time has elapsed and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed, using the specified scheduler to run the timer. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after the due time has elapsed. + is null. + + + + Returns an observable sequence that produces a single value at the specified absolute due time, using the specified scheduler to run the timer. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value at due time. + is null. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run timers. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value after due time has elapsed and then each period. + is less than TimeSpan.Zero. + is null. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time, using the specified scheduler to run timers. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + is null. + + + + Timestamps each element in an observable sequence using the local system clock. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + An observable sequence with timestamp information on elements. + is null. + + + + Timestamp each element in an observable sequence using the clock of the specified scheduler. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + Scheduler used to compute timestamps. + An observable sequence with timestamp information on elements. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + The sequence of windows. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of windows. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Internal interface describing the LINQ to Events query language. + + + + + Base class for classes that expose an observable sequence as a well-known event pattern (sender, event arguments). + Contains functionality to maintain a map of event handler delegates to observable sequence subscriptions. Subclasses + should only add an event with custom add and remove methods calling into the base class's operations. + + The type of the sender that raises the event. + The type of the event data generated by the event. + + + + Creates a new event pattern source. + + Source sequence to expose as an event. + Delegate used to invoke the event for each element of the sequence. + or is null. + + + + Adds the specified event handler, causing a subscription to the underlying source. + + Event handler to add. The same delegate should be passed to the Remove operation in order to remove the event handler. + Invocation delegate to raise the event in the derived class. + or is null. + + + + Removes the specified event handler, causing a disposal of the corresponding subscription to the underlying source that was created during the Add operation. + + Event handler to remove. This should be the same delegate as one that was passed to the Add operation. + is null. + + + + Represents a .NET event invocation consisting of the weakly typed object that raised the event and the data that was generated by the event. + + The type of the event data generated by the event. + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + The type of the sender that raised the event. + The type of the event data generated by the event. + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Determines whether the current EventPattern<TSender, TEventArgs> object represents the same event as a specified EventPattern<TSender, TEventArgs> object. + + An object to compare to the current EventPattern<TSender, TEventArgs> object. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>. + + The System.Object to compare with the current EventPattern<TSender, TEventArgs>. + true if the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>; otherwise, false. + + + + Returns the hash code for the current EventPattern<TSender, TEventArgs> instance. + + A hash code for the current EventPattern<TSender, TEventArgs> instance. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent the same event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent a different event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects don't represent the same event; otherwise, false. + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Base class for historical schedulers, which are virtual time schedulers that use DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Base class for virtual time schedulers. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts the virtual time scheduler. + + + + + Stops the virtual time scheduler. + + + + + Advances the scheduler's clock to the specified time, running all work till that point. + + Absolute time to advance the scheduler's clock to. + is in the past. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan. + + Relative time to advance the scheduler's clock by. + is negative. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time. + + Relative time to advance the scheduler's clock by. + is negative. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Discovers scheduler services by interface type. The base class implementation supports + only the IStopwatchProvider service. To influence service discovery - such as adding + support for other scheduler services - derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Gets whether the scheduler is enabled to run work. + + + + + Gets the comparer used to compare absolute time values. + + + + + Gets the scheduler's absolute time clock value. + + + + + Gets the scheduler's notion of current time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial clock value. + + + + Creates a new historical scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Provides a virtual time scheduler that uses DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Base class for virtual time schedulers using a priority queue for scheduled items. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the resulting sequence, after transformation through the subject. + + + + Creates an observable that can be connected and disconnected from its source. + + Underlying observable source sequence that can be connected and disconnected from the wrapper. + Subject exposed by the connectable observable, receiving data from the underlying source sequence upon connection. + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable object used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Subscribes an observer to the observable sequence. No values from the underlying observable source will be received unless a connection was established through the Connect method. + + Observer that will receive values from the underlying observable source when the current ConnectableObservable instance is connected through a call to Connect. + Disposable used to unsubscribe from the observable sequence. + + + + Provides a set of static methods for creating subjects. + + + + + Creates a subject from the specified observer and observable. + + The type of the elements received by the observer. + The type of the elements produced by the observable sequence. + The observer used to send messages to the subject. + The observable used to subscribe to messages sent from the subject. + Subject implemented using the given observer and observable. + or is null. + + + + Synchronizes the messages sent to the subject. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Subject whose messages are synchronized. + is null. + + + + Synchronizes the messages sent to the subject and notifies observers on the specified scheduler. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Scheduler to notify observers on. + Subject whose messages are synchronized and whose observers are notified on the given scheduler. + or is null. + + + + Represents the result of an asynchronous operation. + The last value before the OnCompleted notification, or the error received through OnError, is sent to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject that can only receive one value and that value is cached for all future observations. + + + + + Notifies all subscribed observers about the end of the sequence, also causing the last received value to be sent out (if any). + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Sends a value to the subject. The last value received before successful termination will be sent to all subscribed and future observers. + + The value to store in the subject. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Gets an awaitable object for the current AsyncSubject. + + Object that can be awaited. + + + + Specifies a callback action that will be invoked when the subject completes. + + Callback action that will be invoked when the subject completes. + is null. + + + + Gets the last element of the subject, potentially blocking until the subject completes successfully or exceptionally. + + The last element of the subject. Throws an InvalidOperationException if no element was received. + The source sequence is empty. + + + + Indicates whether the subject has observers subscribed to it. + + + + + Gets whether the AsyncSubject has completed. + + + + + Represents a value that changes over time. + Observers can subscribe to the subject to receive the last (or initial) value and all subsequent notifications. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class which creates a subject that caches its last value and starts with the specified value. + + Initial value sent to observers when no other value has been received by the subject yet. + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject. + + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the specified exception. + + The exception to send to all currently subscribed observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all currently subscribed observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribes all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Abstract base class for join patterns. + + + + + Represents a join pattern over one observable sequence. + + The type of the elements in the first source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over two observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + + + + Creates a pattern that matches when all three observable sequences have an available element. + + The type of the elements in the third observable sequence. + Observable sequence to match with the two previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over three observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + + + + Creates a pattern that matches when all four observable sequences have an available element. + + The type of the elements in the fourth observable sequence. + Observable sequence to match with the three previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over four observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + + + + Creates a pattern that matches when all five observable sequences have an available element. + + The type of the elements in the fifth observable sequence. + Observable sequence to match with the four previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over five observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + + + + Creates a pattern that matches when all six observable sequences have an available element. + + The type of the elements in the sixth observable sequence. + Observable sequence to match with the five previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over six observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + + + + Creates a pattern that matches when all seven observable sequences have an available element. + + The type of the elements in the seventh observable sequence. + Observable sequence to match with the six previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over seven observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + + + + Creates a pattern that matches when all eight observable sequences have an available element. + + The type of the elements in the eighth observable sequence. + Observable sequence to match with the seven previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over eight observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + + + + Creates a pattern that matches when all nine observable sequences have an available element. + + The type of the elements in the ninth observable sequence. + Observable sequence to match with the eight previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over nine observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + + + + Creates a pattern that matches when all ten observable sequences have an available element. + + The type of the elements in the tenth observable sequence. + Observable sequence to match with the nine previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over ten observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + + + + Creates a pattern that matches when all eleven observable sequences have an available element. + + The type of the elements in the eleventh observable sequence. + Observable sequence to match with the ten previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over eleven observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + + + + Creates a pattern that matches when all twelve observable sequences have an available element. + + The type of the elements in the twelfth observable sequence. + Observable sequence to match with the eleven previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over twelve observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + + + + Creates a pattern that matches when all thirteen observable sequences have an available element. + + The type of the elements in the thirteenth observable sequence. + Observable sequence to match with the twelve previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over thirteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + + + + Creates a pattern that matches when all fourteen observable sequences have an available element. + + The type of the elements in the fourteenth observable sequence. + Observable sequence to match with the thirteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over fourteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + + + + Creates a pattern that matches when all fifteen observable sequences have an available element. + + The type of the elements in the fifteenth observable sequence. + Observable sequence to match with the fourteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over fifteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + + + + Creates a pattern that matches when all sixteen observable sequences have an available element. + + The type of the elements in the sixteenth observable sequence. + Observable sequence to match with the fifteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over sixteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents an execution plan for join patterns. + + The type of the results produced by the plan. + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed and future observers, subject to buffer trimming policies. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class with the specified buffer size, window and scheduler. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is less than zero. -or- is less than TimeSpan.Zero. + is null. + + + + Initializes a new instance of the class with the specified buffer size and window. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + is less than zero. -or- is less than TimeSpan.Zero. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified scheduler. + + Scheduler the observers are invoked on. + is null. + + + + Initializes a new instance of the class with the specified buffer size and scheduler. + + Maximum element count of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than zero. + + + + Initializes a new instance of the class with the specified buffer size. + + Maximum element count of the replay buffer. + is less than zero. + + + + Initializes a new instance of the class with the specified window and scheduler. + + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than TimeSpan.Zero. + + + + Initializes a new instance of the class with the specified window. + + Maximum time length of the replay buffer. + is less than TimeSpan.Zero. + + + + Notifies all subscribed and future observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Notifies all subscribed and future observers about the specified exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed and future observers about the end of the sequence. + + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribe all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + The System.Reactive.Threading.Tasks namespace contains helpers for the conversion between tasks and observable sequences. + + + + + Provides a set of static methods for converting tasks to observable sequences. + + + + + Returns an observable sequence that signals when the task completes. + + Task to convert to an observable sequence. + An observable sequence that produces a unit value when the task completes, or propagates the exception produced by the task. + is null. + If the specified task object supports cancellation, consider using instead. + + + + Returns an observable sequence that propagates the result of the task. + + The type of the result produced by the task. + Task to convert to an observable sequence. + An observable sequence that produces the task's result, or propagates the exception produced by the task. + is null. + If the specified task object supports cancellation, consider using instead. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + The state to use as the underlying task's AsyncState. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence. + The state to use as the underlying task's AsyncState. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Represents a value associated with time interval information. + The time interval can represent the time it took to produce the value, the interval relative to a previous value, the value's delivery time relative to a base, etc. + + The type of the value being annotated with time interval information. + + + + Constructs a time interval value. + + The value to be annotated with a time interval. + Time interval associated with the value. + + + + Determines whether the current TimeInterval<T> value has the same Value and Interval as a specified TimeInterval<T> value. + + An object to compare to the current TimeInterval<T> value. + true if both TimeInterval<T> values have the same Value and Interval; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has the same Value and Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values don't have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has a different Value or Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current TimeInterval<T>. + + The System.Object to compare with the current TimeInterval<T>. + true if the specified System.Object is equal to the current TimeInterval<T>; otherwise, false. + + + + Returns the hash code for the current TimeInterval<T> value. + + A hash code for the current TimeInterval<T> value. + + + + Returns a string representation of the current TimeInterval<T> value. + + String representation of the current TimeInterval<T> value. + + + + Gets the value. + + + + + Gets the interval. + + + + + Represents value with a timestamp on it. + The timestamp typically represents the time the value was received, using an IScheduler's clock to obtain the current time. + + The type of the value being timestamped. + + + + Constructs a timestamped value. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + + + + Determines whether the current Timestamped<T> value has the same Value and Timestamp as a specified Timestamped<T> value. + + An object to compare to the current Timestamped<T> value. + true if both Timestamped<T> values have the same Value and Timestamp; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has the same Value and Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values don't have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has a different Value or Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current Timestamped<T>. + + The System.Object to compare with the current Timestamped<T>. + true if the specified System.Object is equal to the current Timestamped<T>; otherwise, false. + + + + Returns the hash code for the current Timestamped<T> value. + + A hash code for the current Timestamped<T> value. + + + + Returns a string representation of the current Timestamped<T> value. + + String representation of the current Timestamped<T> value. + + + + Gets the value. + + + + + Gets the timestamp. + + + + + A helper class with a factory method for creating Timestamped<T> instances. + + + + + Creates an instance of a Timestamped<T>. This is syntactic sugar that uses type inference + to avoid specifying a type in a constructor call, which is very useful when using anonymous types. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + Creates a new timestamped value. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Could not find event '{0}' on object of type '{1}'.. + + + + + Looks up a localized string similar to Could not find event '{0}' on type '{1}'.. + + + + + Looks up a localized string similar to Add method should take 1 parameter.. + + + + + Looks up a localized string similar to The second parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Event is missing the add method.. + + + + + Looks up a localized string similar to Event is missing the remove method.. + + + + + Looks up a localized string similar to The event delegate must have a void return type.. + + + + + Looks up a localized string similar to The event delegate must have exactly two parameters.. + + + + + Looks up a localized string similar to Remove method should take 1 parameter.. + + + + + Looks up a localized string similar to The first parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Remove method of a WinRT event should take an EventRegistrationToken.. + + + + + Looks up a localized string similar to Sequence contains more than one element.. + + + + + Looks up a localized string similar to Sequence contains more than one matching element.. + + + + + Looks up a localized string similar to Sequence contains no elements.. + + + + + Looks up a localized string similar to Sequence contains no matching element.. + + + + + Looks up a localized string similar to {0} cannot be called when the scheduler is already running. Try using Sleep instead.. + + + + diff --git a/packages/Rx-Linq.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Linq.dll b/packages/Rx-Linq.2.1.30214.0/lib/Portable-Net45+WinRT45+WP8/System.Reactive.Linq.dll new file mode 100644 index 0000000000000000000000000000000000000000..6d89076a1aca277e8d01c8bcc75c20b5e972158d GIT binary patch literal 692296 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

        &-NffP3B*FwlhfDydM5ZIk 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 z zvh~W69_6=pJwAVnCI8Uc!l~Q&_m8N3%UsZforBAIKR;(JVyZC}d^);0q9c>Kz TS3I?glsOi7_~3;bEY|-6={PW4 literal 0 HcmV?d00001 diff --git a/packages/Rx-Linq.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Linq.XML b/packages/Rx-Linq.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Linq.XML new file mode 100644 index 000000000..0c79927a5 --- /dev/null +++ b/packages/Rx-Linq.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Linq.XML @@ -0,0 +1,7587 @@ + + + + System.Reactive.Linq + + + + + The System.Reactive.Joins namespace contains classes used to express join patterns over observable sequences using fluent method syntax. + + + + + Provides a set of extension methods for virtual time scheduling. + + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Attribute applied to static classes providing expression tree forms of query methods, + mapping those to the corresponding methods for local query execution on the specified + target class type. + + + + + Creates a new mapping to the specified local execution query method implementation type. + + Type with query methods for local execution. + + + + Gets the type with the implementation of local query methods. + + + + + Provides a set of static methods for writing in-memory queries over observable sequences. + + + + + Uses to determine which source in to return, choosing if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Default source to select in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence on the specified scheduler if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Scheduler to generate an empty sequence on in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated after each repeated completed. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated upon the completion of an iteration through the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Concatenates the observable sequences obtained by running the for each element in the given enumerable . + + The type of the elements in the enumerable source sequence. + The type of the elements in the observable result sequence. + Enumerable source for which each element will be mapped onto an observable source that will be concatenated in the result sequence. + Function to select an observable source for each element in the . + The observable sequence obtained by concatenating the sources returned by for each element in the . + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, select the sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Sequence returned in case evaluates false. + if evaluates true; otherwise. + or or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + if evaluates true; an empty sequence otherwise. + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence generated on the specified scheduler. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Scheduler to generate an empty sequence on in case evaluates false. + if evaluates true; an empty sequence otherwise. + or or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated before each repeated is subscribed to. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated before subscription to the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Invokes the specified function asynchronously, surfacing the result through an observable sequence. + + The type of the result returned by the function. + Function to run asynchronously. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence + + The type of the result returned by the function. + Function to run asynchronously. + Scheduler to run the function on. + An observable sequence exposing the function's result value, or an exception. + or is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the action asynchronously, surfacing the result through an observable sequence. + + Action to run asynchronously. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the action asynchronously on the specified scheduler, surfacing the result through an observable sequence. + + Action to run asynchronously. + Scheduler to run the action on. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + or is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value, + and the specified result selector function is used to select the result value. + + The type of the elements in the source sequence. + The type of the accumulator value. + The type of the resulting value. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + A function to transform the final accumulator value into the result value. + An observable sequence containing a single element with the final accumulator value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to aggregate over. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether all elements of an observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains any elements. + + The type of the elements in the source sequence. + An observable sequence to check for non-emptiness. + An observable sequence containing a single element determining whether the source sequence contains any elements. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether any element of an observable sequence satisfies a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether any elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + (Asynchronous) The sum of the elements in the source sequence is larger than . + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using the default equality comparer. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using a specified System.Collections.Generic.IEqualityComparer<T>. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An equality comparer to compare elements. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the element at a specified index in a sequence. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence. + is null. + is less than zero. + (Asynchronous) is greater than or equal to the number of elements in the source sequence. + + + + Returns the element at a specified index in a sequence or a default value if the index is out of range. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence, or a default value if the index is outside the bounds of the source sequence. + is null. + is less than zero. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Determines whether an observable sequence is empty. + + The type of the elements in the source sequence. + An observable sequence to check for emptiness. + An observable sequence containing a single element determining whether the source sequence is empty. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + An observable sequence containing a single element with the maximum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + An observable sequence containing a single element with the minimum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the only element of an observable sequence, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence. + is null. + (Asynchronous) The source sequence contains more than one element. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence, or a default value if no such element exists. + is null. + (Asynchronous) The source sequence contains more than one element. + + + + Returns the only element of an observable sequence that matches the predicate, or a default value if no such element exists; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + (Asynchronous) The sequence contains more than one element that satisfies the condition in the predicate. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates an array from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get an array of elements for. + An observable sequence containing a single element with an array containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a list from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get a list of elements for. + An observable sequence containing a single element with a list containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Multicasts the source sequence notifications through the specified subject to the resulting connectable observable. Upon connection of the + connectable observable, the subject is subscribed to the source exactly one, and messages are forwarded to the observers registered with + the connectable observable. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be pushed into the specified subject. + Subject to push source elements into. + A connectable observable sequence that upon connection causes the source sequence to push results into the specified subject. + or is null. + + + + Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each + subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's + invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements produced by the intermediate subject. + The type of the elements in the result sequence. + Source sequence which will be multicasted in the specified selector function. + Factory function to create an intermediate subject through which the source sequence's elements will be multicast to the selector function. + Selector function which can use the multicasted source sequence subject to the policies enforced by the created subject. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Initial value received by observers upon subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + Initial value received by observers upon subscription. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will only receive the last notification of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will only receive the last notification of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + + The type of the elements in the source sequence. + Connectable observable sequence. + An observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all the notifications of the source. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + Subscribers will receive all the notifications of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Produces an enumerable sequence of consecutive (possibly empty) chunks of the source sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns consecutive (possibly empty) chunks upon each iteration. + is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create a new collector object. + Merges a sequence element with the current collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create the initial collector object. + Merges a sequence element with the current collector. + Factory to replace the current collector by a new collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or or is null. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Invokes an action for each element in the observable sequence, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Returns an enumerator that enumerates all values of the observable sequence. + + The type of the elements in the source sequence. + An observable sequence to get an enumerator for. + The enumerator that can be used to enumerate over the elements in the observable sequence. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Returns an enumerable sequence whose enumeration returns the latest observed element in the source observable sequence. + Enumerators on the resulting sequence will never produce the same element repeatedly, and will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns the last sampled element upon each iteration and subsequently blocks until the next element in the observable source sequence becomes available. + + + + Returns an enumerable sequence whose enumeration returns the most recently observed element in the source observable sequence, using the specified initial value in case no element has been sampled yet. + Enumerators on the resulting sequence never block and can produce the same element repeatedly. + + The type of the elements in the source sequence. + Source observable sequence. + Initial value that will be yielded by the enumerable sequence if no element has been sampled yet. + The enumerable sequence that returns the last sampled element upon each iteration. + is null. + + + + Returns an enumerable sequence whose enumeration blocks until the next element in the source observable sequence becomes available. + Enumerators on the resulting sequence will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that blocks upon each iteration until the next element in the observable source sequence becomes available. + is null. + + + + Returns the only element of an observable sequence, and throws an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence. + is null. + The source sequence contains more than one element. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and throws an exception if there is not exactly one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method throws an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence, or a default value if no such element exists. + is null. + The source sequence contains more than one element. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists; this method throws an exception if there is more than one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + The sequence contains more than one element that satisfies the condition in the predicate. + + + + + Waits for the observable sequence to complete and returns the last element of the sequence. + If the sequence terminates with an OnError notification, the exception is throw. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + This only invokes observer callbacks on a scheduler. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a scheduler, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + This only invokes observer callbacks on a synchronization context. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a synchronization context, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified scheduler. In order to invoke observer + callbacks on a scheduler, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified synchronization context. In order to invoke observer + callbacks on a synchronization context, use . + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently. + This overload is useful to "fix" an observable sequence that exhibits concurrent callbacks on individual observers, which is invalid behavior for the query processor. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + It's invalid behavior - according to the observer grammar - for a sequence to exhibit concurrent callbacks on a given observer. + This operator can be used to "fix" a source that doesn't conform to this rule. + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently, using the specified gate object. + This overload is useful when writing n-ary query operators, in order to prevent concurrent callbacks from different sources by synchronizing on a common gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Subscribes an observer to an enumerable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Disposable object that can be used to unsubscribe the observer from the enumerable + or is null. + + + + Subscribes an observer to an enumerable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Scheduler to perform the enumeration on. + Disposable object that can be used to unsubscribe the observer from the enumerable + or or is null. + + + + Converts an observable sequence to an enumerable sequence. + + The type of the elements in the source sequence. + An observable sequence to convert to an enumerable sequence. + The enumerable sequence containing the elements in the observable sequence. + is null. + + + + Exposes an observable sequence as an object with an Action-based .NET event. + + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with an Action<TSource>-based .NET event. + + The type of the elements in the source sequence. + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with a .NET event, conforming to the standard .NET event pattern. + + The type of the event data generated by the event. + Observable source sequence. + The event source object. + is null. + + + + Converts an enumerable sequence to an observable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + The observable sequence whose elements are pulled from the given enumerable sequence. + is null. + + + + Converts an enumerable sequence to an observable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + Scheduler to run the enumeration of the input sequence on. + The observable sequence whose elements are pulled from the given enumerable sequence. + or is null. + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Observable factory function to invoke for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger an invocation of the given observable factory function. + is null. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence with no elements. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + An observable sequence with no elements. + is null. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + The generated sequence. + or or is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements, using the specified scheduler to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Scheduler on which to run the generator loop. + The generated sequence. + or or or is null. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence whose observers will never get called. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence whose observers will never get called. + + + + Generates an observable sequence of integral numbers within a specified range. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + + + + Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to send out observer messages. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + Scheduler to run the generator loop on. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + is null. + + + + Generates an observable sequence that repeats the given element infinitely. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + An observable sequence that repeats the given element infinitely. + + + + Generates an observable sequence that repeats the given element infinitely, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element infinitely. + is null. + + + + Generates an observable sequence that repeats the given element the specified number of times. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + + + + Generates an observable sequence that repeats the given element the specified number of times, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + is null. + + + + Returns an observable sequence that contains a single element. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + An observable sequence containing the single specified element. + + + + Returns an observable sequence that contains a single element, using the specified scheduler to send out observer messages. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + Scheduler to send the single element on. + An observable sequence containing the single specified element. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Factory function to obtain a resource object. + Factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + + + + Creates a pattern that matches when both observable sequences have an available element. + + The type of the elements in the left sequence. + The type of the elements in the right sequence. + Observable sequence to match with the right sequence. + Observable sequence to match with the left sequence. + Pattern object that matches when both observable sequences have an available element. + or is null. + + + + Matches when the observable sequence has an available element and projects the element by invoking the selector function. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, returned by the selector function. + Observable sequence to apply the selector on. + Selector that will be invoked for elements in the source sequence. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + or is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results from matching several patterns. + is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results form matching several patterns. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that surfaces either of the given sequences, whichever reacted first. + or is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + A function invoked to define the boundaries of the produced buffers. A new buffer is started when the previous one is closed. + An observable sequence of buffers. + or is null. + + + + Projects each element of an observable sequence into zero or more buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequence indicating buffer opening events, also passed to the closing selector to obtain a sequence of buffer closing events. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + Observable sequence whose elements denote the creation of new buffers. + A function invoked to define the closing of each produced buffer. + An observable sequence of buffers. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer boundary events. + Source sequence to produce buffers over. + Sequence of buffer boundary markers. The current buffer is closed and a new buffer is opened upon receiving a boundary marker. + An observable sequence of buffers. + or is null. + + + + Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler. + + The type of the elements in the source sequence and sequences returned by the exception handler function. + The type of the exception to catch and handle. Needs to derive from . + Source sequence. + Exception handler function, producing another observable sequence. + An observable sequence containing the source sequence's elements, followed by the elements produced by the handler's resulting observable sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source sequence and handler sequence. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results when an error occurred in the first sequence. + An observable sequence containing the first sequence's elements, followed by the elements of the second sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Merges two observable sequences into one observable sequence by using the selector function whenever one of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke whenever either of the sources produces an element. + An observable sequence containing the result of combining elements of both sources using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke whenever any of the sources produces an element. For efficiency, the input list is reused after the selector returns. Either aggregate or copy the values during the function call. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful termination of the first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that contains the elements of the first sequence, followed by those of the second the sequence. + or is null. + + + + Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all inner observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + An observable sequence that contains the elements of each observed inner sequence, in sequential order. + is null. + + + + Merges elements from all inner observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that merges the elements of the inner sequences. + is null. + + + + Merges elements from all inner observable sequences into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + Maximum number of inner observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the inner sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the observable sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences, and using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + is less than or equal to zero. + + + + Merges elements from two observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + The observable sequence that merges the elements of the given sequences. + or is null. + + + + Merges elements from two observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + Scheduler used to introduce concurrency for making subscriptions to the given sequences. + The observable sequence that merges the elements of the given sequences. + or or is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful or exceptional termination of the first. + + The type of the elements in the source sequences. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results after the first sequence terminates. + An observable sequence that concatenates the first and second sequence, even if the first sequence terminates exceptionally. + or is null. + + + + Concatenates all of the specified observable sequences, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Returns the elements from the source observable sequence only after the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of skip behavior. + Source sequence to propagate elements for. + Observable sequence that triggers propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation. + or is null. + + + + Switches between the inner observable sequences such that the resulting sequence always produces elements from the most recently received inner observable sequence. + Each time a new inner observable sequence is received, the previous inner observable sequence is unsubscribed from. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received. + is null. + + + + Returns the elements from the source observable sequence until the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of take behavior. + Source sequence to propagate elements for. + Observable sequence that terminates propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + A function invoked to define the boundaries of the produced windows. A new window is started when the previous one is closed. + An observable sequence of windows. + or is null. + + + + Projects each element of an observable sequence into zero or more windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequence indicating window opening events, also passed to the closing selector to obtain a sequence of window closing events. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + Observable sequence whose elements denote the creation of new windows. + A function invoked to define the closing of each produced window. + An observable sequence of windows. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window boundary events. + Source sequence to produce windows over. + Sequence of window boundary markers. The current window is closed and a new window is opened upon receiving a boundary marker. + An observable sequence of windows. + or is null. + + + + Merges two observable sequences into one observable sequence by combining their elements in a pairwise fashion. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges an observable sequence and an enumerable sequence into one observable sequence by using the selector function. + + The type of the elements in the first observable source sequence. + The type of the elements in the second enumerable source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second enumerable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Hides the identity of an observable sequence. + + The type of the elements in the source sequence. + An observable sequence whose identity to hide. + An observable sequence that hides the identity of the source sequence. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Number of elements to skip between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than or equal to zero. + + + + Dematerializes the explicit notification values of an observable sequence as implicit notifications. + + The type of the elements materialized in the source sequence notification objects. + An observable sequence containing explicit notification values which have to be turned into implicit notifications. + An observable sequence exhibiting the behavior corresponding to the source sequence's notification values. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + An observable sequence only containing the distinct contiguous elements from the source sequence. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct contiguous elements from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + Equality comparer for computed key values. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or or is null. + + + + Invokes an action for each element in the observable sequence, and propagates all observer messages through the result sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or or is null. + + + + Invokes the observer's methods for each message in the source sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Observer whose methods to invoke as part of the source sequence's observation. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes a specified action after the source observable sequence terminates gracefully or exceptionally. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke after the source observable sequence terminates. + Source sequence with the action-invoking termination behavior applied. + or is null. + + + + Ignores all elements in an observable sequence leaving only the termination messages. + + The type of the elements in the source sequence. + Source sequence. + An empty observable sequence that signals termination, successful or exceptional, of the source sequence. + is null. + + + + Materializes the implicit notifications of an observable sequence as explicit notification values. + + The type of the elements in the source sequence. + An observable sequence to get notification values for. + An observable sequence containing the materialized notification values from the source sequence. + is null. + + + + Repeats the observable sequence indefinitely. + + The type of the elements in the source sequence. + Observable sequence to repeat. + The observable sequence producing the elements of the given sequence repeatedly and sequentially. + is null. + + + + Repeats the observable sequence a specified number of times. + + The type of the elements in the source sequence. + Observable sequence to repeat. + Number of times to repeat the sequence. + The observable sequence producing the elements of the given sequence repeatedly. + is null. + is less than zero. + + + + Repeats the source observable sequence until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + + + + Repeats the source observable sequence the specified number of times or until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + Number of times to repeat the sequence. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + is less than zero. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to accumulate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to accumulate over. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Bypasses a specified number of elements at the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to bypass at the end of the source sequence. + An observable sequence containing the source sequence elements except for the bypassed ones at the end. + is null. + is less than zero. + + This operator accumulates a queue with a length enough to store the first elements. As more elements are + received, elements are taken from the front of the queue and produced on the result sequence. This causes elements to be delayed. + + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Returns a specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a specified number of contiguous elements from the end of an observable sequence, using the specified scheduler to drain the queue. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + Scheduler used to drain the queue upon completion of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + or is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a list with the specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing a single list with the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements. Upon completion of the + source sequence, this buffer is produced on the result sequence. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + An observable sequence of windows. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Number of elements to skip between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than or equal to zero. + + + + Converts the elements of an observable sequence to the specified type. + + The type to convert the elements in the source sequence to. + The observable sequence that contains the elements to be converted. + An observable sequence that contains each element of the source sequence converted to the specified type. + is null. + + + + Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), whose default value will be taken if the sequence is empty. + The sequence to return a default value for if it is empty. + An observable sequence that contains the default value for the TSource type if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns the elements of the specified sequence or the specified value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), and the specified default value which will be taken if the sequence is empty. + The sequence to return the specified value for if it is empty. + The value to return if the sequence is empty. + An observable sequence that contains the specified default value if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns an observable sequence that contains only distinct elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + An observable sequence only containing the distinct elements from the source sequence. + is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct elements from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + Equality comparer for source elements. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Groups the elements of an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered. + + or or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or is null. + + + + Correlates the elements of two sequences based on overlapping durations, and groups the results. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any element of the left sequence with overlapping elements from the right observable sequence. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Correlates the elements of two sequences based on overlapping durations. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any two overlapping elements of the left and right observable sequences. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Filters the elements of an observable sequence based on the specified type. + + The type to filter the elements in the source sequence on. + The observable sequence that contains the elements to be filtered. + An observable sequence that contains elements from the input sequence of type TResult. + is null. + + + + Projects each element of an observable sequence into a new form. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of an observable sequence into a new form by incorporating the element's index. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the other sequence and the elements in the result sequence. + An observable sequence of elements to project. + An observable sequence to project each element from the source sequence onto. + An observable sequence whose elements are the result of projecting each source element onto the other sequence and merging all the resulting sequences together. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element. + A transform function to apply when an error occurs in the source sequence. + A transform function to apply when the end of the source sequence is reached. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element; the second parameter represents the index of the source element. + A transform function to apply when an error occurs in the source sequence; the second parameter represents the index of the source element. + A transform function to apply when the end of the source sequence is reached; the second parameter represents the number of elements observed. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + The index of each source element is used in the projected form of that element. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Bypasses a specified number of elements in an observable sequence and then returns the remaining elements. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to skip before returning the remaining elements. + An observable sequence that contains the elements that occur after the specified index in the input sequence. + is null. + is less than zero. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Returns a specified number of contiguous elements from the start of an observable sequence. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + An observable sequence that contains the specified number of elements from the start of the input sequence. + is null. + is less than zero. + + + + Returns a specified number of contiguous elements from the start of an observable sequence, using the specified scheduler for the edge case of Take(0). + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + Scheduler used to produce an OnCompleted message in case count is set to 0. + An observable sequence that contains the specified number of elements from the start of the input sequence. + or is null. + is less than zero. + + + + Returns elements from an observable sequence as long as a specified condition is true. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Returns elements from an observable sequence as long as a specified condition is true. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Filters the elements of an observable sequence based on a predicate. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a condition. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Filters the elements of an observable sequence based on a predicate by incorporating the element's index. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a conditio; the second parameter of the function represents the index of the source element. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a buffer. + Maximum element count of a buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Time shifts the observable sequence by the specified relative time duration. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence by the specified relative time duration, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence based on a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or is null. + + + + Time shifts the observable sequence based on a subscription delay and a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Sequence indicating the delay for the subscription to the source. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or or is null. + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Time-shifted sequence. + is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Returns an observable sequence that produces a value after each period. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Returns an observable sequence that produces a value after each period, using the specified scheduler to run timers and to send out observer messages. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + is null. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Samples the observable sequence at each interval. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Sampled observable sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the observable sequence at each interval, using the specified scheduler to run sampling timers. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Scheduler to run the sampling timer on. + Sampled observable sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the source observable sequence using a samper observable sequence producing sampling ticks. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + The type of the elements in the sampling sequence. + Source sequence to sample. + Sampling tick sequence. + Sampled observable sequence. + or is null. + + + + Skips elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements for the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements from the observable source sequence until the specified start time. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + An observable sequence with the elements skipped until the specified start time. + is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Skips elements from the observable source sequence until the specified start time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + Scheduler to run the timer on. + An observable sequence with the elements skipped until the specified start time. + or is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Takes elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Takes elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Returns elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified schedulers to run timers and to drain the collected elements. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + Scheduler to drain the collected elements. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Takes elements for the specified duration until the specified end time. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + An observable sequence with the elements taken until the specified end time. + is null. + + + + Takes elements for the specified duration until the specified end time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + Scheduler to run the timer on. + An observable sequence with the elements taken until the specified end time. + or is null. + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + The throttled sequence. + is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration, using the specified scheduler to run throttling timers. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + Scheduler to run the throttle timers on. + The throttled sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another value within a computed throttle duration. + + The type of the elements in the source sequence. + The type of the elements in the throttle sequences selected for each element in the source sequence. + Source sequence to throttle. + Selector function to retrieve a sequence indicating the throttle duration for each given element. + The throttled sequence. + or is null. + + This operator throttles the source sequence by holding on to each element for the duration denoted by . + If another element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this + whole process. For streams where the duration computed by applying the to each element overlaps with + the occurrence of the successor element, the resulting stream won't produce any elements. In order to reduce the volume of a stream whilst + guaranteeing the periodic production of elements, consider using the Observable.Sample set of operators. + + + + + Records the time interval between consecutive elements in an observable sequence. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + An observable sequence with time interval information on elements. + is null. + + + + Records the time interval between consecutive elements in an observable sequence, using the specified scheduler to compute time intervals. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + Scheduler used to compute time intervals. + An observable sequence with time interval information on elements. + or is null. + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + The source sequence with a TimeoutException in case of a timeout. + is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + The source sequence with a TimeoutException in case of a timeout. + is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or is null. + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or or is null. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + An observable sequence that produces a value after the due time has elapsed. + + + + Returns an observable sequence that produces a single value at the specified absolute due time. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + An observable sequence that produces a value at due time. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after due time has elapsed and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed, using the specified scheduler to run the timer. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after the due time has elapsed. + is null. + + + + Returns an observable sequence that produces a single value at the specified absolute due time, using the specified scheduler to run the timer. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value at due time. + is null. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run timers. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value after due time has elapsed and then each period. + is less than TimeSpan.Zero. + is null. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time, using the specified scheduler to run timers. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + is null. + + + + Timestamps each element in an observable sequence using the local system clock. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + An observable sequence with timestamp information on elements. + is null. + + + + Timestamp each element in an observable sequence using the clock of the specified scheduler. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + Scheduler used to compute timestamps. + An observable sequence with timestamp information on elements. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + The sequence of windows. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of windows. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Internal interface describing the LINQ to Events query language. + + + + + Base class for classes that expose an observable sequence as a well-known event pattern (sender, event arguments). + Contains functionality to maintain a map of event handler delegates to observable sequence subscriptions. Subclasses + should only add an event with custom add and remove methods calling into the base class's operations. + + The type of the sender that raises the event. + The type of the event data generated by the event. + + + + Creates a new event pattern source. + + Source sequence to expose as an event. + Delegate used to invoke the event for each element of the sequence. + or is null. + + + + Adds the specified event handler, causing a subscription to the underlying source. + + Event handler to add. The same delegate should be passed to the Remove operation in order to remove the event handler. + Invocation delegate to raise the event in the derived class. + or is null. + + + + Removes the specified event handler, causing a disposal of the corresponding subscription to the underlying source that was created during the Add operation. + + Event handler to remove. This should be the same delegate as one that was passed to the Add operation. + is null. + + + + Represents a .NET event invocation consisting of the weakly typed object that raised the event and the data that was generated by the event. + + The type of the event data generated by the event. + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + The type of the sender that raised the event. + The type of the event data generated by the event. + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Determines whether the current EventPattern<TSender, TEventArgs> object represents the same event as a specified EventPattern<TSender, TEventArgs> object. + + An object to compare to the current EventPattern<TSender, TEventArgs> object. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>. + + The System.Object to compare with the current EventPattern<TSender, TEventArgs>. + true if the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>; otherwise, false. + + + + Returns the hash code for the current EventPattern<TSender, TEventArgs> instance. + + A hash code for the current EventPattern<TSender, TEventArgs> instance. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent the same event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent a different event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects don't represent the same event; otherwise, false. + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Base class for historical schedulers, which are virtual time schedulers that use DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Base class for virtual time schedulers. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts the virtual time scheduler. + + + + + Stops the virtual time scheduler. + + + + + Advances the scheduler's clock to the specified time, running all work till that point. + + Absolute time to advance the scheduler's clock to. + is in the past. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan. + + Relative time to advance the scheduler's clock by. + is negative. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time. + + Relative time to advance the scheduler's clock by. + is negative. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Discovers scheduler services by interface type. The base class implementation supports + only the IStopwatchProvider service. To influence service discovery - such as adding + support for other scheduler services - derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Gets whether the scheduler is enabled to run work. + + + + + Gets the comparer used to compare absolute time values. + + + + + Gets the scheduler's absolute time clock value. + + + + + Gets the scheduler's notion of current time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial clock value. + + + + Creates a new historical scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Provides a virtual time scheduler that uses DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Base class for virtual time schedulers using a priority queue for scheduled items. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the resulting sequence, after transformation through the subject. + + + + Creates an observable that can be connected and disconnected from its source. + + Underlying observable source sequence that can be connected and disconnected from the wrapper. + Subject exposed by the connectable observable, receiving data from the underlying source sequence upon connection. + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable object used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Subscribes an observer to the observable sequence. No values from the underlying observable source will be received unless a connection was established through the Connect method. + + Observer that will receive values from the underlying observable source when the current ConnectableObservable instance is connected through a call to Connect. + Disposable used to unsubscribe from the observable sequence. + + + + Provides a set of static methods for creating subjects. + + + + + Creates a subject from the specified observer and observable. + + The type of the elements received by the observer. + The type of the elements produced by the observable sequence. + The observer used to send messages to the subject. + The observable used to subscribe to messages sent from the subject. + Subject implemented using the given observer and observable. + or is null. + + + + Synchronizes the messages sent to the subject. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Subject whose messages are synchronized. + is null. + + + + Synchronizes the messages sent to the subject and notifies observers on the specified scheduler. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Scheduler to notify observers on. + Subject whose messages are synchronized and whose observers are notified on the given scheduler. + or is null. + + + + Represents the result of an asynchronous operation. + The last value before the OnCompleted notification, or the error received through OnError, is sent to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject that can only receive one value and that value is cached for all future observations. + + + + + Notifies all subscribed observers about the end of the sequence, also causing the last received value to be sent out (if any). + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Sends a value to the subject. The last value received before successful termination will be sent to all subscribed and future observers. + + The value to store in the subject. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Gets the last element of the subject, potentially blocking until the subject completes successfully or exceptionally. + + The last element of the subject. Throws an InvalidOperationException if no element was received. + The source sequence is empty. + + + + Indicates whether the subject has observers subscribed to it. + + + + + Gets whether the AsyncSubject has completed. + + + + + Represents a value that changes over time. + Observers can subscribe to the subject to receive the last (or initial) value and all subsequent notifications. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class which creates a subject that caches its last value and starts with the specified value. + + Initial value sent to observers when no other value has been received by the subject yet. + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject. + + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the specified exception. + + The exception to send to all currently subscribed observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all currently subscribed observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribes all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Abstract base class for join patterns. + + + + + Represents a join pattern over one observable sequence. + + The type of the elements in the first source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over two observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + + + + Creates a pattern that matches when all three observable sequences have an available element. + + The type of the elements in the third observable sequence. + Observable sequence to match with the two previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over three observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + + + + Creates a pattern that matches when all four observable sequences have an available element. + + The type of the elements in the fourth observable sequence. + Observable sequence to match with the three previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over four observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents an execution plan for join patterns. + + The type of the results produced by the plan. + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed and future observers, subject to buffer trimming policies. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class with the specified buffer size, window and scheduler. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is less than zero. -or- is less than TimeSpan.Zero. + is null. + + + + Initializes a new instance of the class with the specified buffer size and window. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + is less than zero. -or- is less than TimeSpan.Zero. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified scheduler. + + Scheduler the observers are invoked on. + is null. + + + + Initializes a new instance of the class with the specified buffer size and scheduler. + + Maximum element count of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than zero. + + + + Initializes a new instance of the class with the specified buffer size. + + Maximum element count of the replay buffer. + is less than zero. + + + + Initializes a new instance of the class with the specified window and scheduler. + + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than TimeSpan.Zero. + + + + Initializes a new instance of the class with the specified window. + + Maximum time length of the replay buffer. + is less than TimeSpan.Zero. + + + + Notifies all subscribed and future observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Notifies all subscribed and future observers about the specified exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed and future observers about the end of the sequence. + + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribe all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + The System.Reactive.Threading.Tasks namespace contains helpers for the conversion between tasks and observable sequences. + + + + + Represents a value associated with time interval information. + The time interval can represent the time it took to produce the value, the interval relative to a previous value, the value's delivery time relative to a base, etc. + + The type of the value being annotated with time interval information. + + + + Constructs a time interval value. + + The value to be annotated with a time interval. + Time interval associated with the value. + + + + Determines whether the current TimeInterval<T> value has the same Value and Interval as a specified TimeInterval<T> value. + + An object to compare to the current TimeInterval<T> value. + true if both TimeInterval<T> values have the same Value and Interval; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has the same Value and Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values don't have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has a different Value or Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current TimeInterval<T>. + + The System.Object to compare with the current TimeInterval<T>. + true if the specified System.Object is equal to the current TimeInterval<T>; otherwise, false. + + + + Returns the hash code for the current TimeInterval<T> value. + + A hash code for the current TimeInterval<T> value. + + + + Returns a string representation of the current TimeInterval<T> value. + + String representation of the current TimeInterval<T> value. + + + + Gets the value. + + + + + Gets the interval. + + + + + Represents value with a timestamp on it. + The timestamp typically represents the time the value was received, using an IScheduler's clock to obtain the current time. + + The type of the value being timestamped. + + + + Constructs a timestamped value. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + + + + Determines whether the current Timestamped<T> value has the same Value and Timestamp as a specified Timestamped<T> value. + + An object to compare to the current Timestamped<T> value. + true if both Timestamped<T> values have the same Value and Timestamp; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has the same Value and Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values don't have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has a different Value or Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current Timestamped<T>. + + The System.Object to compare with the current Timestamped<T>. + true if the specified System.Object is equal to the current Timestamped<T>; otherwise, false. + + + + Returns the hash code for the current Timestamped<T> value. + + A hash code for the current Timestamped<T> value. + + + + Returns a string representation of the current Timestamped<T> value. + + String representation of the current Timestamped<T> value. + + + + Gets the value. + + + + + Gets the timestamp. + + + + + A helper class with a factory method for creating Timestamped<T> instances. + + + + + Creates an instance of a Timestamped<T>. This is syntactic sugar that uses type inference + to avoid specifying a type in a constructor call, which is very useful when using anonymous types. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + Creates a new timestamped value. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Could not find event '{0}' on object of type '{1}'.. + + + + + Looks up a localized string similar to Could not find event '{0}' on type '{1}'.. + + + + + Looks up a localized string similar to Add method should take 1 parameter.. + + + + + Looks up a localized string similar to The second parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Event is missing the add method.. + + + + + Looks up a localized string similar to Event is missing the remove method.. + + + + + Looks up a localized string similar to The event delegate must have a void return type.. + + + + + Looks up a localized string similar to The event delegate must have exactly two parameters.. + + + + + Looks up a localized string similar to Remove method should take 1 parameter.. + + + + + Looks up a localized string similar to The first parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Remove method of a WinRT event should take an EventRegistrationToken.. + + + + + Looks up a localized string similar to Sequence contains more than one element.. + + + + + Looks up a localized string similar to Sequence contains more than one matching element.. + + + + + Looks up a localized string similar to Sequence contains no elements.. + + + + + Looks up a localized string similar to Sequence contains no matching element.. + + + + + Looks up a localized string similar to {0} cannot be called when the scheduler is already running. Try using Sleep instead.. + + + + diff --git a/packages/Rx-Linq.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Linq.dll b/packages/Rx-Linq.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.Linq.dll new file mode 100644 index 0000000000000000000000000000000000000000..f9ef530a6ef122a3791fe685f3cedcbb750322a0 GIT binary patch literal 393824 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

        wCnuDoE4f-%K= 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 J+V_E5$pGiXPr(2H literal 0 HcmV?d00001 diff --git a/packages/Rx-Linq.2.1.30214.0/lib/SL4/_._ b/packages/Rx-Linq.2.1.30214.0/lib/SL4/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/Rx-Linq.2.1.30214.0/lib/SL5/System.Reactive.Linq.XML b/packages/Rx-Linq.2.1.30214.0/lib/SL5/System.Reactive.Linq.XML new file mode 100644 index 000000000..2ee99f58d --- /dev/null +++ b/packages/Rx-Linq.2.1.30214.0/lib/SL5/System.Reactive.Linq.XML @@ -0,0 +1,10510 @@ + + + + System.Reactive.Linq + + + +

        + The System.Reactive.Joins namespace contains classes used to express join patterns over observable sequences using fluent method syntax. + + + + + Provides a set of extension methods for virtual time scheduling. + + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Attribute applied to static classes providing expression tree forms of query methods, + mapping those to the corresponding methods for local query execution on the specified + target class type. + + + + + Creates a new mapping to the specified local execution query method implementation type. + + Type with query methods for local execution. + + + + Gets the type with the implementation of local query methods. + + + + + Provides a set of static methods for writing in-memory queries over observable sequences. + + + + + Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. + The loop can be quit prematurely by setting the specified cancellation token. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Cancellation token used to stop the loop. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. + The loop can be quit prematurely by setting the specified cancellation token. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Cancellation token used to stop the loop. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Uses to determine which source in to return, choosing if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Default source to select in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence on the specified scheduler if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Scheduler to generate an empty sequence on in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated after each repeated completed. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated upon the completion of an iteration through the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Concatenates the observable sequences obtained by running the for each element in the given enumerable . + + The type of the elements in the enumerable source sequence. + The type of the elements in the observable result sequence. + Enumerable source for which each element will be mapped onto an observable source that will be concatenated in the result sequence. + Function to select an observable source for each element in the . + The observable sequence obtained by concatenating the sources returned by for each element in the . + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, select the sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Sequence returned in case evaluates false. + if evaluates true; otherwise. + or or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + if evaluates true; an empty sequence otherwise. + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence generated on the specified scheduler. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Scheduler to generate an empty sequence on in case evaluates false. + if evaluates true; an empty sequence otherwise. + or or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated before each repeated is subscribed to. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated before subscription to the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the fourteenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the fourteenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Invokes the specified function asynchronously, surfacing the result through an observable sequence. + + The type of the result returned by the function. + Function to run asynchronously. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence + + The type of the result returned by the function. + Function to run asynchronously. + Scheduler to run the function on. + An observable sequence exposing the function's result value, or an exception. + or is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the asynchronous function, surfacing the result through an observable sequence. + + The type of the result returned by the asynchronous function. + Asynchronous function to run. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the asynchronous function, surfacing the result through an observable sequence. + The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information. + + The type of the result returned by the asynchronous function. + Asynchronous function to run. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + If any subscription to the resulting sequence is disposed, the CancellationToken is set. The observer associated to the disposed + subscription won't see the TaskCanceledException, but other observers will. You can protect against this using the Catch operator. + Be careful when handing out the resulting sequence because of this behavior. The most common use is to have a single subscription + to the resulting sequence, which controls the CancellationToken state. Alternatively, you can control subscription behavior using + multicast operators. + + + + + + + Invokes the action asynchronously, surfacing the result through an observable sequence. + + Action to run asynchronously. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the action asynchronously on the specified scheduler, surfacing the result through an observable sequence. + + Action to run asynchronously. + Scheduler to run the action on. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + or is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the asynchronous action, surfacing the result through an observable sequence. + + Asynchronous action to run. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the asynchronous action, surfacing the result through an observable sequence. + The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information. + + Asynchronous action to run. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + If any subscription to the resulting sequence is disposed, the CancellationToken is set. The observer associated to the disposed + subscription won't see the TaskCanceledException, but other observers will. You can protect against this using the Catch operator. + Be careful when handing out the resulting sequence because of this behavior. The most common use is to have a single subscription + to the resulting sequence, which controls the CancellationToken state. Alternatively, you can control subscription behavior using + multicast operators. + + + + + + + Converts to asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. + + The type of the result returned by the asynchronous function. + Asynchronous function to convert. + An observable sequence exposing the result of invoking the function, or an exception. + is null. + + + + Converts to asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. + The CancellationToken passed to the asynchronous function is tied to the observable sequence's subscription that triggered the function's invocation and can be used for best-effort cancellation. + + The type of the result returned by the asynchronous function. + Asynchronous function to convert. + An observable sequence exposing the result of invoking the function, or an exception. + is null. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous function will be signaled. + + + + Converts to asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. + + Asynchronous action to convert. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + + Converts to asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. + The CancellationToken passed to the asynchronous action is tied to the observable sequence's subscription that triggered the action's invocation and can be used for best-effort cancellation. + + Asynchronous action to convert. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous function will be signaled. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the sixteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the sixteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + The type of the sixteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + The type of the sixteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value, + and the specified result selector function is used to select the result value. + + The type of the elements in the source sequence. + The type of the accumulator value. + The type of the resulting value. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + A function to transform the final accumulator value into the result value. + An observable sequence containing a single element with the final accumulator value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to aggregate over. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether all elements of an observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains any elements. + + The type of the elements in the source sequence. + An observable sequence to check for non-emptiness. + An observable sequence containing a single element determining whether the source sequence contains any elements. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether any element of an observable sequence satisfies a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether any elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + (Asynchronous) The sum of the elements in the source sequence is larger than . + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using the default equality comparer. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using a specified System.Collections.Generic.IEqualityComparer<T>. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An equality comparer to compare elements. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the element at a specified index in a sequence. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence. + is null. + is less than zero. + (Asynchronous) is greater than or equal to the number of elements in the source sequence. + + + + Returns the element at a specified index in a sequence or a default value if the index is out of range. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence, or a default value if the index is outside the bounds of the source sequence. + is null. + is less than zero. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Determines whether an observable sequence is empty. + + The type of the elements in the source sequence. + An observable sequence to check for emptiness. + An observable sequence containing a single element determining whether the source sequence is empty. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + An observable sequence containing a single element with the maximum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + An observable sequence containing a single element with the minimum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the only element of an observable sequence, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence. + is null. + (Asynchronous) The source sequence contains more than one element. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence, or a default value if no such element exists. + is null. + (Asynchronous) The source sequence contains more than one element. + + + + Returns the only element of an observable sequence that matches the predicate, or a default value if no such element exists; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + (Asynchronous) The sequence contains more than one element that satisfies the condition in the predicate. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates an array from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get an array of elements for. + An observable sequence containing a single element with an array containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a list from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get a list of elements for. + An observable sequence containing a single element with a list containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Multicasts the source sequence notifications through the specified subject to the resulting connectable observable. Upon connection of the + connectable observable, the subject is subscribed to the source exactly one, and messages are forwarded to the observers registered with + the connectable observable. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be pushed into the specified subject. + Subject to push source elements into. + A connectable observable sequence that upon connection causes the source sequence to push results into the specified subject. + or is null. + + + + Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each + subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's + invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements produced by the intermediate subject. + The type of the elements in the result sequence. + Source sequence which will be multicasted in the specified selector function. + Factory function to create an intermediate subject through which the source sequence's elements will be multicast to the selector function. + Selector function which can use the multicasted source sequence subject to the policies enforced by the created subject. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Initial value received by observers upon subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + Initial value received by observers upon subscription. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will only receive the last notification of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will only receive the last notification of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + + The type of the elements in the source sequence. + Connectable observable sequence. + An observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all the notifications of the source. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + Subscribers will receive all the notifications of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Produces an enumerable sequence of consecutive (possibly empty) chunks of the source sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns consecutive (possibly empty) chunks upon each iteration. + is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create a new collector object. + Merges a sequence element with the current collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create the initial collector object. + Merges a sequence element with the current collector. + Factory to replace the current collector by a new collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or or is null. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Invokes an action for each element in the observable sequence, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Returns an enumerator that enumerates all values of the observable sequence. + + The type of the elements in the source sequence. + An observable sequence to get an enumerator for. + The enumerator that can be used to enumerate over the elements in the observable sequence. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Returns an enumerable sequence whose enumeration returns the latest observed element in the source observable sequence. + Enumerators on the resulting sequence will never produce the same element repeatedly, and will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns the last sampled element upon each iteration and subsequently blocks until the next element in the observable source sequence becomes available. + + + + Returns an enumerable sequence whose enumeration returns the most recently observed element in the source observable sequence, using the specified initial value in case no element has been sampled yet. + Enumerators on the resulting sequence never block and can produce the same element repeatedly. + + The type of the elements in the source sequence. + Source observable sequence. + Initial value that will be yielded by the enumerable sequence if no element has been sampled yet. + The enumerable sequence that returns the last sampled element upon each iteration. + is null. + + + + Returns an enumerable sequence whose enumeration blocks until the next element in the source observable sequence becomes available. + Enumerators on the resulting sequence will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that blocks upon each iteration until the next element in the observable source sequence becomes available. + is null. + + + + Returns the only element of an observable sequence, and throws an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence. + is null. + The source sequence contains more than one element. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and throws an exception if there is not exactly one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method throws an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence, or a default value if no such element exists. + is null. + The source sequence contains more than one element. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists; this method throws an exception if there is more than one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + The sequence contains more than one element that satisfies the condition in the predicate. + + + + + Waits for the observable sequence to complete and returns the last element of the sequence. + If the sequence terminates with an OnError notification, the exception is throw. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + This only invokes observer callbacks on a scheduler. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a scheduler, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + This only invokes observer callbacks on a synchronization context. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a synchronization context, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified scheduler. In order to invoke observer + callbacks on a scheduler, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified synchronization context. In order to invoke observer + callbacks on a synchronization context, use . + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently. + This overload is useful to "fix" an observable sequence that exhibits concurrent callbacks on individual observers, which is invalid behavior for the query processor. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + It's invalid behavior - according to the observer grammar - for a sequence to exhibit concurrent callbacks on a given observer. + This operator can be used to "fix" a source that doesn't conform to this rule. + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently, using the specified gate object. + This overload is useful when writing n-ary query operators, in order to prevent concurrent callbacks from different sources by synchronizing on a common gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Subscribes an observer to an enumerable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Disposable object that can be used to unsubscribe the observer from the enumerable + or is null. + + + + Subscribes an observer to an enumerable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Scheduler to perform the enumeration on. + Disposable object that can be used to unsubscribe the observer from the enumerable + or or is null. + + + + Converts an observable sequence to an enumerable sequence. + + The type of the elements in the source sequence. + An observable sequence to convert to an enumerable sequence. + The enumerable sequence containing the elements in the observable sequence. + is null. + + + + Exposes an observable sequence as an object with an Action-based .NET event. + + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with an Action<TSource>-based .NET event. + + The type of the elements in the source sequence. + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with a .NET event, conforming to the standard .NET event pattern. + + The type of the event data generated by the event. + Observable source sequence. + The event source object. + is null. + + + + Converts an enumerable sequence to an observable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + The observable sequence whose elements are pulled from the given enumerable sequence. + is null. + + + + Converts an enumerable sequence to an observable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + Scheduler to run the enumeration of the input sequence on. + The observable sequence whose elements are pulled from the given enumerable sequence. + or is null. + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to produce elements. + The observable sequence surfacing the elements produced by the asynchronous method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to produce elements. + The observable sequence surfacing the elements produced by the asynchronous method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Observable factory function to invoke for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger an invocation of the given observable factory function. + is null. + + + + Returns an observable sequence that starts the specified asynchronous factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Asynchronous factory function to start for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger the given asynchronous observable factory function to be started. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Returns an observable sequence that starts the specified cancellable asynchronous factory function whenever a new observer subscribes. + The CancellationToken passed to the asynchronous factory function is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Asynchronous factory function to start for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger the given asynchronous observable factory function to be started. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous observable factory function will be signaled. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence with no elements. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + An observable sequence with no elements. + is null. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + The generated sequence. + or or is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements, using the specified scheduler to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Scheduler on which to run the generator loop. + The generated sequence. + or or or is null. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence whose observers will never get called. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence whose observers will never get called. + + + + Generates an observable sequence of integral numbers within a specified range. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + + + + Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to send out observer messages. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + Scheduler to run the generator loop on. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + is null. + + + + Generates an observable sequence that repeats the given element infinitely. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + An observable sequence that repeats the given element infinitely. + + + + Generates an observable sequence that repeats the given element infinitely, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element infinitely. + is null. + + + + Generates an observable sequence that repeats the given element the specified number of times. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + + + + Generates an observable sequence that repeats the given element the specified number of times, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + is null. + + + + Returns an observable sequence that contains a single element. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + An observable sequence containing the single specified element. + + + + Returns an observable sequence that contains a single element, using the specified scheduler to send out observer messages. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + Scheduler to send the single element on. + An observable sequence containing the single specified element. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Factory function to obtain a resource object. + Factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. The resource is obtained and used through asynchronous methods. + The CancellationToken passed to the asynchronous methods is tied to the returned disposable subscription, allowing best-effort cancellation at any stage of the resource acquisition or usage. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Asynchronous factory function to obtain a resource object. + Asynchronous factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous resource factory and observable factory functions will be signaled. + + + + Creates a pattern that matches when both observable sequences have an available element. + + The type of the elements in the left sequence. + The type of the elements in the right sequence. + Observable sequence to match with the right sequence. + Observable sequence to match with the left sequence. + Pattern object that matches when both observable sequences have an available element. + or is null. + + + + Matches when the observable sequence has an available element and projects the element by invoking the selector function. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, returned by the selector function. + Observable sequence to apply the selector on. + Selector that will be invoked for elements in the source sequence. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + or is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results from matching several patterns. + is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results form matching several patterns. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that surfaces either of the given sequences, whichever reacted first. + or is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + A function invoked to define the boundaries of the produced buffers. A new buffer is started when the previous one is closed. + An observable sequence of buffers. + or is null. + + + + Projects each element of an observable sequence into zero or more buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequence indicating buffer opening events, also passed to the closing selector to obtain a sequence of buffer closing events. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + Observable sequence whose elements denote the creation of new buffers. + A function invoked to define the closing of each produced buffer. + An observable sequence of buffers. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer boundary events. + Source sequence to produce buffers over. + Sequence of buffer boundary markers. The current buffer is closed and a new buffer is opened upon receiving a boundary marker. + An observable sequence of buffers. + or is null. + + + + Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler. + + The type of the elements in the source sequence and sequences returned by the exception handler function. + The type of the exception to catch and handle. Needs to derive from . + Source sequence. + Exception handler function, producing another observable sequence. + An observable sequence containing the source sequence's elements, followed by the elements produced by the handler's resulting observable sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source sequence and handler sequence. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results when an error occurred in the first sequence. + An observable sequence containing the first sequence's elements, followed by the elements of the second sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Merges two observable sequences into one observable sequence by using the selector function whenever one of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke whenever either of the sources produces an element. + An observable sequence containing the result of combining elements of both sources using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Sixteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke whenever any of the sources produces an element. For efficiency, the input list is reused after the selector returns. Either aggregate or copy the values during the function call. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful termination of the first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that contains the elements of the first sequence, followed by those of the second the sequence. + or is null. + + + + Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all inner observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + An observable sequence that contains the elements of each observed inner sequence, in sequential order. + is null. + + + + Concatenates all task results, as long as the previous task terminated successfully. + + The type of the results produced by the tasks. + Observable sequence of tasks. + An observable sequence that contains the results of each task, in sequential order. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a concatenation operation using . + + + + Merges elements from all inner observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that merges the elements of the inner sequences. + is null. + + + + Merges results from all source tasks into a single observable sequence. + + The type of the results produced by the source tasks. + Observable sequence of tasks. + The observable sequence that merges the results of the source tasks. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a merge operation using . + + + + Merges elements from all inner observable sequences into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + Maximum number of inner observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the inner sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the observable sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences, and using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + is less than or equal to zero. + + + + Merges elements from two observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + The observable sequence that merges the elements of the given sequences. + or is null. + + + + Merges elements from two observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + Scheduler used to introduce concurrency for making subscriptions to the given sequences. + The observable sequence that merges the elements of the given sequences. + or or is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful or exceptional termination of the first. + + The type of the elements in the source sequences. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results after the first sequence terminates. + An observable sequence that concatenates the first and second sequence, even if the first sequence terminates exceptionally. + or is null. + + + + Concatenates all of the specified observable sequences, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Returns the elements from the source observable sequence only after the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of skip behavior. + Source sequence to propagate elements for. + Observable sequence that triggers propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation. + or is null. + + + + Switches between the inner observable sequences such that the resulting sequence always produces elements from the most recently received inner observable sequence. + Each time a new inner observable sequence is received, the previous inner observable sequence is unsubscribed from. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received. + is null. + + + + Switches between the tasks such that the resulting sequence always produces results from the most recently received task. + Each time a new task is received, the previous task's result is ignored. + + The type of the results produced by the source tasks. + Observable sequence of tasks. + The observable sequence that at any point in time produces the result of the most recent task that has been received. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a switch operation using . + + + + Returns the elements from the source observable sequence until the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of take behavior. + Source sequence to propagate elements for. + Observable sequence that terminates propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + A function invoked to define the boundaries of the produced windows. A new window is started when the previous one is closed. + An observable sequence of windows. + or is null. + + + + Projects each element of an observable sequence into zero or more windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequence indicating window opening events, also passed to the closing selector to obtain a sequence of window closing events. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + Observable sequence whose elements denote the creation of new windows. + A function invoked to define the closing of each produced window. + An observable sequence of windows. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window boundary events. + Source sequence to produce windows over. + Sequence of window boundary markers. The current window is closed and a new window is opened upon receiving a boundary marker. + An observable sequence of windows. + or is null. + + + + Merges two observable sequences into one observable sequence by combining their elements in a pairwise fashion. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Sixteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges an observable sequence and an enumerable sequence into one observable sequence by using the selector function. + + The type of the elements in the first observable source sequence. + The type of the elements in the second enumerable source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second enumerable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Hides the identity of an observable sequence. + + The type of the elements in the source sequence. + An observable sequence whose identity to hide. + An observable sequence that hides the identity of the source sequence. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Number of elements to skip between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than or equal to zero. + + + + Dematerializes the explicit notification values of an observable sequence as implicit notifications. + + The type of the elements materialized in the source sequence notification objects. + An observable sequence containing explicit notification values which have to be turned into implicit notifications. + An observable sequence exhibiting the behavior corresponding to the source sequence's notification values. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + An observable sequence only containing the distinct contiguous elements from the source sequence. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct contiguous elements from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + Equality comparer for computed key values. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or or is null. + + + + Invokes an action for each element in the observable sequence, and propagates all observer messages through the result sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or or is null. + + + + Invokes the observer's methods for each message in the source sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Observer whose methods to invoke as part of the source sequence's observation. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes a specified action after the source observable sequence terminates gracefully or exceptionally. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke after the source observable sequence terminates. + Source sequence with the action-invoking termination behavior applied. + or is null. + + + + Ignores all elements in an observable sequence leaving only the termination messages. + + The type of the elements in the source sequence. + Source sequence. + An empty observable sequence that signals termination, successful or exceptional, of the source sequence. + is null. + + + + Materializes the implicit notifications of an observable sequence as explicit notification values. + + The type of the elements in the source sequence. + An observable sequence to get notification values for. + An observable sequence containing the materialized notification values from the source sequence. + is null. + + + + Repeats the observable sequence indefinitely. + + The type of the elements in the source sequence. + Observable sequence to repeat. + The observable sequence producing the elements of the given sequence repeatedly and sequentially. + is null. + + + + Repeats the observable sequence a specified number of times. + + The type of the elements in the source sequence. + Observable sequence to repeat. + Number of times to repeat the sequence. + The observable sequence producing the elements of the given sequence repeatedly. + is null. + is less than zero. + + + + Repeats the source observable sequence until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + + + + Repeats the source observable sequence the specified number of times or until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + Number of times to repeat the sequence. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + is less than zero. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to accumulate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to accumulate over. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Bypasses a specified number of elements at the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to bypass at the end of the source sequence. + An observable sequence containing the source sequence elements except for the bypassed ones at the end. + is null. + is less than zero. + + This operator accumulates a queue with a length enough to store the first elements. As more elements are + received, elements are taken from the front of the queue and produced on the result sequence. This causes elements to be delayed. + + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Returns a specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a specified number of contiguous elements from the end of an observable sequence, using the specified scheduler to drain the queue. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + Scheduler used to drain the queue upon completion of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + or is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a list with the specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing a single list with the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements. Upon completion of the + source sequence, this buffer is produced on the result sequence. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + An observable sequence of windows. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Number of elements to skip between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than or equal to zero. + + + + Converts the elements of an observable sequence to the specified type. + + The type to convert the elements in the source sequence to. + The observable sequence that contains the elements to be converted. + An observable sequence that contains each element of the source sequence converted to the specified type. + is null. + + + + Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), whose default value will be taken if the sequence is empty. + The sequence to return a default value for if it is empty. + An observable sequence that contains the default value for the TSource type if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns the elements of the specified sequence or the specified value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), and the specified default value which will be taken if the sequence is empty. + The sequence to return the specified value for if it is empty. + The value to return if the sequence is empty. + An observable sequence that contains the specified default value if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns an observable sequence that contains only distinct elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + An observable sequence only containing the distinct elements from the source sequence. + is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct elements from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + Equality comparer for source elements. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Groups the elements of an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered. + + or or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or is null. + + + + Correlates the elements of two sequences based on overlapping durations, and groups the results. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any element of the left sequence with overlapping elements from the right observable sequence. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Correlates the elements of two sequences based on overlapping durations. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any two overlapping elements of the left and right observable sequences. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Filters the elements of an observable sequence based on the specified type. + + The type to filter the elements in the source sequence on. + The observable sequence that contains the elements to be filtered. + An observable sequence that contains elements from the input sequence of type TResult. + is null. + + + + Projects each element of an observable sequence into a new form. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of an observable sequence into a new form by incorporating the element's index. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the other sequence and the elements in the result sequence. + An observable sequence of elements to project. + An observable sequence to project each element from the source sequence onto. + An observable sequence whose elements are the result of projecting each source element onto the other sequence and merging all the resulting sequences together. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to a task and merges all of the task results into one observable sequence. + + The type of the elements in the source sequence. + The type of the result produced by the projected tasks and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of the tasks executed for each element of the input sequence. + This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + or is null. + + + + Projects each element of an observable sequence to a task with cancellation support and merges all of the task results into one observable sequence. + + The type of the elements in the source sequence. + The type of the result produced by the projected tasks and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of the tasks executed for each element of the input sequence. + This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to a task, invokes the result selector for the source element and the task result, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the results produced by the projected intermediate tasks. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate task results. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element. + or or is null. + This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + + + + Projects each element of an observable sequence to a task with cancellation support, invokes the result selector for the source element and the task result, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the results produced by the projected intermediate tasks. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate task results. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element. + or or is null. + This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element. + A transform function to apply when an error occurs in the source sequence. + A transform function to apply when the end of the source sequence is reached. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element; the second parameter represents the index of the source element. + A transform function to apply when an error occurs in the source sequence; the second parameter represents the index of the source element. + A transform function to apply when the end of the source sequence is reached; the second parameter represents the number of elements observed. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + The index of each source element is used in the projected form of that element. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Bypasses a specified number of elements in an observable sequence and then returns the remaining elements. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to skip before returning the remaining elements. + An observable sequence that contains the elements that occur after the specified index in the input sequence. + is null. + is less than zero. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Returns a specified number of contiguous elements from the start of an observable sequence. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + An observable sequence that contains the specified number of elements from the start of the input sequence. + is null. + is less than zero. + + + + Returns a specified number of contiguous elements from the start of an observable sequence, using the specified scheduler for the edge case of Take(0). + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + Scheduler used to produce an OnCompleted message in case count is set to 0. + An observable sequence that contains the specified number of elements from the start of the input sequence. + or is null. + is less than zero. + + + + Returns elements from an observable sequence as long as a specified condition is true. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Returns elements from an observable sequence as long as a specified condition is true. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Filters the elements of an observable sequence based on a predicate. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a condition. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Filters the elements of an observable sequence based on a predicate by incorporating the element's index. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a conditio; the second parameter of the function represents the index of the source element. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a buffer. + Maximum element count of a buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Time shifts the observable sequence by the specified relative time duration. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence by the specified relative time duration, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence based on a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or is null. + + + + Time shifts the observable sequence based on a subscription delay and a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Sequence indicating the delay for the subscription to the source. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or or is null. + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Time-shifted sequence. + is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Returns an observable sequence that produces a value after each period. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Returns an observable sequence that produces a value after each period, using the specified scheduler to run timers and to send out observer messages. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + is null. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Samples the observable sequence at each interval. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Sampled observable sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the observable sequence at each interval, using the specified scheduler to run sampling timers. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Scheduler to run the sampling timer on. + Sampled observable sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the source observable sequence using a samper observable sequence producing sampling ticks. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + The type of the elements in the sampling sequence. + Source sequence to sample. + Sampling tick sequence. + Sampled observable sequence. + or is null. + + + + Skips elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements for the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements from the observable source sequence until the specified start time. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + An observable sequence with the elements skipped until the specified start time. + is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Skips elements from the observable source sequence until the specified start time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + Scheduler to run the timer on. + An observable sequence with the elements skipped until the specified start time. + or is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Takes elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Takes elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Returns elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified schedulers to run timers and to drain the collected elements. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + Scheduler to drain the collected elements. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Takes elements for the specified duration until the specified end time. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + An observable sequence with the elements taken until the specified end time. + is null. + + + + Takes elements for the specified duration until the specified end time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + Scheduler to run the timer on. + An observable sequence with the elements taken until the specified end time. + or is null. + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + The throttled sequence. + is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration, using the specified scheduler to run throttling timers. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + Scheduler to run the throttle timers on. + The throttled sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another value within a computed throttle duration. + + The type of the elements in the source sequence. + The type of the elements in the throttle sequences selected for each element in the source sequence. + Source sequence to throttle. + Selector function to retrieve a sequence indicating the throttle duration for each given element. + The throttled sequence. + or is null. + + This operator throttles the source sequence by holding on to each element for the duration denoted by . + If another element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this + whole process. For streams where the duration computed by applying the to each element overlaps with + the occurrence of the successor element, the resulting stream won't produce any elements. In order to reduce the volume of a stream whilst + guaranteeing the periodic production of elements, consider using the Observable.Sample set of operators. + + + + + Records the time interval between consecutive elements in an observable sequence. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + An observable sequence with time interval information on elements. + is null. + + + + Records the time interval between consecutive elements in an observable sequence, using the specified scheduler to compute time intervals. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + Scheduler used to compute time intervals. + An observable sequence with time interval information on elements. + or is null. + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + The source sequence with a TimeoutException in case of a timeout. + is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + The source sequence with a TimeoutException in case of a timeout. + is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or is null. + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or or is null. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + An observable sequence that produces a value after the due time has elapsed. + + + + Returns an observable sequence that produces a single value at the specified absolute due time. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + An observable sequence that produces a value at due time. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after due time has elapsed and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed, using the specified scheduler to run the timer. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after the due time has elapsed. + is null. + + + + Returns an observable sequence that produces a single value at the specified absolute due time, using the specified scheduler to run the timer. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value at due time. + is null. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run timers. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value after due time has elapsed and then each period. + is less than TimeSpan.Zero. + is null. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time, using the specified scheduler to run timers. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + is null. + + + + Timestamps each element in an observable sequence using the local system clock. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + An observable sequence with timestamp information on elements. + is null. + + + + Timestamp each element in an observable sequence using the clock of the specified scheduler. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + Scheduler used to compute timestamps. + An observable sequence with timestamp information on elements. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + The sequence of windows. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of windows. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Internal interface describing the LINQ to Events query language. + + + + + Base class for classes that expose an observable sequence as a well-known event pattern (sender, event arguments). + Contains functionality to maintain a map of event handler delegates to observable sequence subscriptions. Subclasses + should only add an event with custom add and remove methods calling into the base class's operations. + + The type of the sender that raises the event. + The type of the event data generated by the event. + + + + Creates a new event pattern source. + + Source sequence to expose as an event. + Delegate used to invoke the event for each element of the sequence. + or is null. + + + + Adds the specified event handler, causing a subscription to the underlying source. + + Event handler to add. The same delegate should be passed to the Remove operation in order to remove the event handler. + Invocation delegate to raise the event in the derived class. + or is null. + + + + Removes the specified event handler, causing a disposal of the corresponding subscription to the underlying source that was created during the Add operation. + + Event handler to remove. This should be the same delegate as one that was passed to the Add operation. + is null. + + + + Represents a .NET event invocation consisting of the weakly typed object that raised the event and the data that was generated by the event. + + The type of the event data generated by the event. + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + The type of the sender that raised the event. + The type of the event data generated by the event. + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Determines whether the current EventPattern<TSender, TEventArgs> object represents the same event as a specified EventPattern<TSender, TEventArgs> object. + + An object to compare to the current EventPattern<TSender, TEventArgs> object. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>. + + The System.Object to compare with the current EventPattern<TSender, TEventArgs>. + true if the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>; otherwise, false. + + + + Returns the hash code for the current EventPattern<TSender, TEventArgs> instance. + + A hash code for the current EventPattern<TSender, TEventArgs> instance. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent the same event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent a different event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects don't represent the same event; otherwise, false. + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Base class for historical schedulers, which are virtual time schedulers that use DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Base class for virtual time schedulers. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts the virtual time scheduler. + + + + + Stops the virtual time scheduler. + + + + + Advances the scheduler's clock to the specified time, running all work till that point. + + Absolute time to advance the scheduler's clock to. + is in the past. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan. + + Relative time to advance the scheduler's clock by. + is negative. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time. + + Relative time to advance the scheduler's clock by. + is negative. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Discovers scheduler services by interface type. The base class implementation supports + only the IStopwatchProvider service. To influence service discovery - such as adding + support for other scheduler services - derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Gets whether the scheduler is enabled to run work. + + + + + Gets the comparer used to compare absolute time values. + + + + + Gets the scheduler's absolute time clock value. + + + + + Gets the scheduler's notion of current time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial clock value. + + + + Creates a new historical scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Provides a virtual time scheduler that uses DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Base class for virtual time schedulers using a priority queue for scheduled items. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the resulting sequence, after transformation through the subject. + + + + Creates an observable that can be connected and disconnected from its source. + + Underlying observable source sequence that can be connected and disconnected from the wrapper. + Subject exposed by the connectable observable, receiving data from the underlying source sequence upon connection. + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable object used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Subscribes an observer to the observable sequence. No values from the underlying observable source will be received unless a connection was established through the Connect method. + + Observer that will receive values from the underlying observable source when the current ConnectableObservable instance is connected through a call to Connect. + Disposable used to unsubscribe from the observable sequence. + + + + Provides a set of static methods for creating subjects. + + + + + Creates a subject from the specified observer and observable. + + The type of the elements received by the observer. + The type of the elements produced by the observable sequence. + The observer used to send messages to the subject. + The observable used to subscribe to messages sent from the subject. + Subject implemented using the given observer and observable. + or is null. + + + + Synchronizes the messages sent to the subject. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Subject whose messages are synchronized. + is null. + + + + Synchronizes the messages sent to the subject and notifies observers on the specified scheduler. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Scheduler to notify observers on. + Subject whose messages are synchronized and whose observers are notified on the given scheduler. + or is null. + + + + Represents the result of an asynchronous operation. + The last value before the OnCompleted notification, or the error received through OnError, is sent to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject that can only receive one value and that value is cached for all future observations. + + + + + Notifies all subscribed observers about the end of the sequence, also causing the last received value to be sent out (if any). + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Sends a value to the subject. The last value received before successful termination will be sent to all subscribed and future observers. + + The value to store in the subject. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Gets the last element of the subject, potentially blocking until the subject completes successfully or exceptionally. + + The last element of the subject. Throws an InvalidOperationException if no element was received. + The source sequence is empty. + + + + Indicates whether the subject has observers subscribed to it. + + + + + Gets whether the AsyncSubject has completed. + + + + + Represents a value that changes over time. + Observers can subscribe to the subject to receive the last (or initial) value and all subsequent notifications. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class which creates a subject that caches its last value and starts with the specified value. + + Initial value sent to observers when no other value has been received by the subject yet. + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject. + + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the specified exception. + + The exception to send to all currently subscribed observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all currently subscribed observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribes all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Abstract base class for join patterns. + + + + + Represents a join pattern over one observable sequence. + + The type of the elements in the first source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over two observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + + + + Creates a pattern that matches when all three observable sequences have an available element. + + The type of the elements in the third observable sequence. + Observable sequence to match with the two previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over three observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + + + + Creates a pattern that matches when all four observable sequences have an available element. + + The type of the elements in the fourth observable sequence. + Observable sequence to match with the three previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over four observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + + + + Creates a pattern that matches when all five observable sequences have an available element. + + The type of the elements in the fifth observable sequence. + Observable sequence to match with the four previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over five observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + + + + Creates a pattern that matches when all six observable sequences have an available element. + + The type of the elements in the sixth observable sequence. + Observable sequence to match with the five previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over six observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + + + + Creates a pattern that matches when all seven observable sequences have an available element. + + The type of the elements in the seventh observable sequence. + Observable sequence to match with the six previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over seven observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + + + + Creates a pattern that matches when all eight observable sequences have an available element. + + The type of the elements in the eighth observable sequence. + Observable sequence to match with the seven previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over eight observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + + + + Creates a pattern that matches when all nine observable sequences have an available element. + + The type of the elements in the ninth observable sequence. + Observable sequence to match with the eight previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over nine observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + + + + Creates a pattern that matches when all ten observable sequences have an available element. + + The type of the elements in the tenth observable sequence. + Observable sequence to match with the nine previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over ten observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + + + + Creates a pattern that matches when all eleven observable sequences have an available element. + + The type of the elements in the eleventh observable sequence. + Observable sequence to match with the ten previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over eleven observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + + + + Creates a pattern that matches when all twelve observable sequences have an available element. + + The type of the elements in the twelfth observable sequence. + Observable sequence to match with the eleven previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over twelve observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + + + + Creates a pattern that matches when all thirteen observable sequences have an available element. + + The type of the elements in the thirteenth observable sequence. + Observable sequence to match with the twelve previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over thirteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + + + + Creates a pattern that matches when all fourteen observable sequences have an available element. + + The type of the elements in the fourteenth observable sequence. + Observable sequence to match with the thirteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over fourteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + + + + Creates a pattern that matches when all fifteen observable sequences have an available element. + + The type of the elements in the fifteenth observable sequence. + Observable sequence to match with the fourteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over fifteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + + + + Creates a pattern that matches when all sixteen observable sequences have an available element. + + The type of the elements in the sixteenth observable sequence. + Observable sequence to match with the fifteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over sixteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents an execution plan for join patterns. + + The type of the results produced by the plan. + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed and future observers, subject to buffer trimming policies. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class with the specified buffer size, window and scheduler. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is less than zero. -or- is less than TimeSpan.Zero. + is null. + + + + Initializes a new instance of the class with the specified buffer size and window. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + is less than zero. -or- is less than TimeSpan.Zero. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified scheduler. + + Scheduler the observers are invoked on. + is null. + + + + Initializes a new instance of the class with the specified buffer size and scheduler. + + Maximum element count of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than zero. + + + + Initializes a new instance of the class with the specified buffer size. + + Maximum element count of the replay buffer. + is less than zero. + + + + Initializes a new instance of the class with the specified window and scheduler. + + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than TimeSpan.Zero. + + + + Initializes a new instance of the class with the specified window. + + Maximum time length of the replay buffer. + is less than TimeSpan.Zero. + + + + Notifies all subscribed and future observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Notifies all subscribed and future observers about the specified exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed and future observers about the end of the sequence. + + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribe all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + The System.Reactive.Threading.Tasks namespace contains helpers for the conversion between tasks and observable sequences. + + + + + Provides a set of static methods for converting tasks to observable sequences. + + + + + Returns an observable sequence that signals when the task completes. + + Task to convert to an observable sequence. + An observable sequence that produces a unit value when the task completes, or propagates the exception produced by the task. + is null. + If the specified task object supports cancellation, consider using instead. + + + + Returns an observable sequence that propagates the result of the task. + + The type of the result produced by the task. + Task to convert to an observable sequence. + An observable sequence that produces the task's result, or propagates the exception produced by the task. + is null. + If the specified task object supports cancellation, consider using instead. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + The state to use as the underlying task's AsyncState. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence. + The state to use as the underlying task's AsyncState. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Represents a value associated with time interval information. + The time interval can represent the time it took to produce the value, the interval relative to a previous value, the value's delivery time relative to a base, etc. + + The type of the value being annotated with time interval information. + + + + Constructs a time interval value. + + The value to be annotated with a time interval. + Time interval associated with the value. + + + + Determines whether the current TimeInterval<T> value has the same Value and Interval as a specified TimeInterval<T> value. + + An object to compare to the current TimeInterval<T> value. + true if both TimeInterval<T> values have the same Value and Interval; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has the same Value and Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values don't have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has a different Value or Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current TimeInterval<T>. + + The System.Object to compare with the current TimeInterval<T>. + true if the specified System.Object is equal to the current TimeInterval<T>; otherwise, false. + + + + Returns the hash code for the current TimeInterval<T> value. + + A hash code for the current TimeInterval<T> value. + + + + Returns a string representation of the current TimeInterval<T> value. + + String representation of the current TimeInterval<T> value. + + + + Gets the value. + + + + + Gets the interval. + + + + + Represents value with a timestamp on it. + The timestamp typically represents the time the value was received, using an IScheduler's clock to obtain the current time. + + The type of the value being timestamped. + + + + Constructs a timestamped value. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + + + + Determines whether the current Timestamped<T> value has the same Value and Timestamp as a specified Timestamped<T> value. + + An object to compare to the current Timestamped<T> value. + true if both Timestamped<T> values have the same Value and Timestamp; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has the same Value and Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values don't have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has a different Value or Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current Timestamped<T>. + + The System.Object to compare with the current Timestamped<T>. + true if the specified System.Object is equal to the current Timestamped<T>; otherwise, false. + + + + Returns the hash code for the current Timestamped<T> value. + + A hash code for the current Timestamped<T> value. + + + + Returns a string representation of the current Timestamped<T> value. + + String representation of the current Timestamped<T> value. + + + + Gets the value. + + + + + Gets the timestamp. + + + + + A helper class with a factory method for creating Timestamped<T> instances. + + + + + Creates an instance of a Timestamped<T>. This is syntactic sugar that uses type inference + to avoid specifying a type in a constructor call, which is very useful when using anonymous types. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + Creates a new timestamped value. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Could not find event '{0}' on object of type '{1}'.. + + + + + Looks up a localized string similar to Could not find event '{0}' on type '{1}'.. + + + + + Looks up a localized string similar to Add method should take 1 parameter.. + + + + + Looks up a localized string similar to The second parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Event is missing the add method.. + + + + + Looks up a localized string similar to Event is missing the remove method.. + + + + + Looks up a localized string similar to The event delegate must have a void return type.. + + + + + Looks up a localized string similar to The event delegate must have exactly two parameters.. + + + + + Looks up a localized string similar to Remove method should take 1 parameter.. + + + + + Looks up a localized string similar to The first parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Remove method of a WinRT event should take an EventRegistrationToken.. + + + + + Looks up a localized string similar to Sequence contains more than one element.. + + + + + Looks up a localized string similar to Sequence contains more than one matching element.. + + + + + Looks up a localized string similar to Sequence contains no elements.. + + + + + Looks up a localized string similar to Sequence contains no matching element.. + + + + + Looks up a localized string similar to {0} cannot be called when the scheduler is already running. Try using Sleep instead.. + + + + diff --git a/packages/Rx-Linq.2.1.30214.0/lib/SL5/System.Reactive.Linq.dll b/packages/Rx-Linq.2.1.30214.0/lib/SL5/System.Reactive.Linq.dll new file mode 100644 index 0000000000000000000000000000000000000000..05ef35b96e91211287e38ba14db407540b3a60ed GIT binary patch literal 687176 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

        HTAP+U+(P*G4tP*adGDe(k_1;qtr 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

        DrxF-5P0kQ$bCXG((A^@Ye!mx?xLwtqY=F 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 + + + System.Reactive.Linq + + + +

        + The System.Reactive.Joins namespace contains classes used to express join patterns over observable sequences using fluent method syntax. + + + + + Provides a set of extension methods for virtual time scheduling. + + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Schedules an action to be executed at dueTime. + + Absolute time representation type. + Relative time representation type. + Scheduler to execute the action on. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + or is null. + + + + Attribute applied to static classes providing expression tree forms of query methods, + mapping those to the corresponding methods for local query execution on the specified + target class type. + + + + + Creates a new mapping to the specified local execution query method implementation type. + + Type with query methods for local execution. + + + + Gets the type with the implementation of local query methods. + + + + + Provides a set of static methods for writing in-memory queries over observable sequences. + + + + + Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, and returns a Task object that will get signaled when the sequence terminates. + The loop can be quit prematurely by setting the specified cancellation token. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Cancellation token used to stop the loop. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and returns a Task object that will get signaled when the sequence terminates. + The loop can be quit prematurely by setting the specified cancellation token. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Cancellation token used to stop the loop. + Task that signals the termination of the sequence. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Uses to determine which source in to return, choosing if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Default source to select in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence on the specified scheduler if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + Scheduler to generate an empty sequence on in case no matching source in is found. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or or is null. + + + + Uses to determine which source in to return, choosing an empty sequence if no match is found. + + The type of the value returned by the selector function, used to look up the resulting source. + The type of the elements in the result sequence. + Selector function invoked to determine the source to lookup in the dictionary. + Dictionary of sources to select from based on the invocation result. + The observable sequence retrieved from the dictionary based on the invocation result, or an empty sequence if no match is found. + or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated after each repeated completed. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated upon the completion of an iteration through the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Concatenates the observable sequences obtained by running the for each element in the given enumerable . + + The type of the elements in the enumerable source sequence. + The type of the elements in the observable result sequence. + Enumerable source for which each element will be mapped onto an observable source that will be concatenated in the result sequence. + Function to select an observable source for each element in the . + The observable sequence obtained by concatenating the sources returned by for each element in the . + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, select the sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Sequence returned in case evaluates false. + if evaluates true; otherwise. + or or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + if evaluates true; an empty sequence otherwise. + or is null. + + + + If the specified evaluates true, select the sequence. Otherwise, return an empty sequence generated on the specified scheduler. + + The type of the elements in the result sequence. + Condition evaluated to decide which sequence to return. + Sequence returned in case evaluates true. + Scheduler to generate an empty sequence on in case evaluates false. + if evaluates true; an empty sequence otherwise. + or or is null. + + + + Repeats the given as long as the specified holds, where the is evaluated before each repeated is subscribed to. + + The type of the elements in the source sequence. + Source to repeat as long as the function evaluates to true. + Condition that will be evaluated before subscription to the , to determine whether repetition of the source is required. + The observable sequence obtained by concatenating the sequence as long as the holds. + or is null. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the fourteenth argument passed to the begin delegate. + The type of the result returned by the end delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Converts a Begin/End invoke function pair into an asynchronous function. + + The type of the first argument passed to the begin delegate. + The type of the second argument passed to the begin delegate. + The type of the third argument passed to the begin delegate. + The type of the fourth argument passed to the begin delegate. + The type of the fifth argument passed to the begin delegate. + The type of the sixth argument passed to the begin delegate. + The type of the seventh argument passed to the begin delegate. + The type of the eighth argument passed to the begin delegate. + The type of the ninth argument passed to the begin delegate. + The type of the tenth argument passed to the begin delegate. + The type of the eleventh argument passed to the begin delegate. + The type of the twelfth argument passed to the begin delegate. + The type of the thirteenth argument passed to the begin delegate. + The type of the fourteenth argument passed to the begin delegate. + The delegate that begins the asynchronous operation. + The delegate that ends the asynchronous operation. + Function that can be used to start the asynchronous operation and retrieve the result (represented as a Unit value) as an observable sequence. + or is null. + Each invocation of the resulting function will cause the asynchronous operation to be started. Subscription to the resulting sequence has no observable side-effect, and each subscription will produce the asynchronous operation's result. + + + + Invokes the specified function asynchronously, surfacing the result through an observable sequence. + + The type of the result returned by the function. + Function to run asynchronously. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the specified function asynchronously on the specified scheduler, surfacing the result through an observable sequence + + The type of the result returned by the function. + Function to run asynchronously. + Scheduler to run the function on. + An observable sequence exposing the function's result value, or an exception. + or is null. + + + The function is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the asynchronous function, surfacing the result through an observable sequence. + + The type of the result returned by the asynchronous function. + Asynchronous function to run. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + + + + + Invokes the asynchronous function, surfacing the result through an observable sequence. + The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information. + + The type of the result returned by the asynchronous function. + Asynchronous function to run. + An observable sequence exposing the function's result value, or an exception. + is null. + + + The function is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the function's result. + + If any subscription to the resulting sequence is disposed, the CancellationToken is set. The observer associated to the disposed + subscription won't see the TaskCanceledException, but other observers will. You can protect against this using the Catch operator. + Be careful when handing out the resulting sequence because of this behavior. The most common use is to have a single subscription + to the resulting sequence, which controls the CancellationToken state. Alternatively, you can control subscription behavior using + multicast operators. + + + + + + + Invokes the action asynchronously, surfacing the result through an observable sequence. + + Action to run asynchronously. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the action asynchronously on the specified scheduler, surfacing the result through an observable sequence. + + Action to run asynchronously. + Scheduler to run the action on. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + or is null. + + + The action is called immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the asynchronous action, surfacing the result through an observable sequence. + + Asynchronous action to run. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + + + + + Invokes the asynchronous action, surfacing the result through an observable sequence. + The CancellationToken is shared by all subscriptions on the resulting observable sequence. See the remarks section for more information. + + Asynchronous action to run. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + The action is started immediately, not during the subscription of the resulting sequence. + Multiple subscriptions to the resulting sequence can observe the action's outcome. + + If any subscription to the resulting sequence is disposed, the CancellationToken is set. The observer associated to the disposed + subscription won't see the TaskCanceledException, but other observers will. You can protect against this using the Catch operator. + Be careful when handing out the resulting sequence because of this behavior. The most common use is to have a single subscription + to the resulting sequence, which controls the CancellationToken state. Alternatively, you can control subscription behavior using + multicast operators. + + + + + + + Converts to asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. + + The type of the result returned by the asynchronous function. + Asynchronous function to convert. + An observable sequence exposing the result of invoking the function, or an exception. + is null. + + + + Converts to asynchronous function into an observable sequence. Each subscription to the resulting sequence causes the function to be started. + The CancellationToken passed to the asynchronous function is tied to the observable sequence's subscription that triggered the function's invocation and can be used for best-effort cancellation. + + The type of the result returned by the asynchronous function. + Asynchronous function to convert. + An observable sequence exposing the result of invoking the function, or an exception. + is null. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous function will be signaled. + + + + Converts to asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. + + Asynchronous action to convert. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + is null. + + + + Converts to asynchronous action into an observable sequence. Each subscription to the resulting sequence causes the action to be started. + The CancellationToken passed to the asynchronous action is tied to the observable sequence's subscription that triggered the action's invocation and can be used for best-effort cancellation. + + Asynchronous action to convert. + An observable sequence exposing a Unit value upon completion of the action, or an exception. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous function will be signaled. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the sixteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Asynchronous function. + is null. + + + + Converts the function into an asynchronous function. Each invocation of the resulting asynchronous function causes an invocation of the original synchronous function on the specified scheduler. + + The type of the first argument passed to the function. + The type of the second argument passed to the function. + The type of the third argument passed to the function. + The type of the fourth argument passed to the function. + The type of the fifth argument passed to the function. + The type of the sixth argument passed to the function. + The type of the seventh argument passed to the function. + The type of the eighth argument passed to the function. + The type of the ninth argument passed to the function. + The type of the tenth argument passed to the function. + The type of the eleventh argument passed to the function. + The type of the twelfth argument passed to the function. + The type of the thirteenth argument passed to the function. + The type of the fourteenth argument passed to the function. + The type of the fifteenth argument passed to the function. + The type of the sixteenth argument passed to the function. + The type of the result returned by the function. + Function to convert to an asynchronous function. + Scheduler to invoke the original function on. + Asynchronous function. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the default scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + The type of the sixteenth argument passed to the action. + Action to convert to an asynchronous action. + Asynchronous action. + is null. + + + + Converts the function into an asynchronous action. Each invocation of the resulting asynchronous action causes an invocation of the original synchronous action on the specified scheduler. + + The type of the first argument passed to the action. + The type of the second argument passed to the action. + The type of the third argument passed to the action. + The type of the fourth argument passed to the action. + The type of the fifth argument passed to the action. + The type of the sixth argument passed to the action. + The type of the seventh argument passed to the action. + The type of the eighth argument passed to the action. + The type of the ninth argument passed to the action. + The type of the tenth argument passed to the action. + The type of the eleventh argument passed to the action. + The type of the twelfth argument passed to the action. + The type of the thirteenth argument passed to the action. + The type of the fourteenth argument passed to the action. + The type of the fifteenth argument passed to the action. + The type of the sixteenth argument passed to the action. + Action to convert to an asynchronous action. + Scheduler to invoke the original action on. + Asynchronous action. + or is null. + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on a supplied event delegate type with a strongly typed sender parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The delegate type of the event to be converted. + The type of the sender that raises the event. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event, conforming to the standard .NET event pattern based on , to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an instance .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the target object type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Object instance that exposes the event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with an parameter, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEventPattern, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEventPattern, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a static .NET event, conforming to the standard .NET event pattern with a strongly typed sender and strongly typed event arguments, to an observable sequence. + Each event invocation is surfaced through an OnNext message in the resulting sequence. + Reflection is used to discover the event based on the specified type and the specified event name. + For conversion of events that don't conform to the standard .NET event pattern, use any of the FromEvent overloads instead. + + The type of the sender that raises the event. + The type of the event data generated by the event. + Type that exposes the static event to convert. + Name of the event to convert. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains data representations of invocations of the underlying .NET event. + or or is null. + The event could not be found. -or- The event does not conform to the standard .NET event pattern. -or- The event's first argument type is not assignable to TSender. -or- The event's second argument type is not assignable to TEventArgs. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEventPattern calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEventPattern that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a conversion function to obtain the event delegate. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + A function used to convert the given event handler to a delegate compatible with the underlying .NET event. The resulting delegate is used in calls to the addHandler and removeHandler action parameters. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a .NET event to an observable sequence, using a supplied event delegate type. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The delegate type of the event to be converted. + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts a generic Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + The type of the event data generated by the event. + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + The current is captured during the call to FromEvent, and is used to post add and remove handler invocations. + This behavior ensures add and remove handler operations for thread-affine events are accessed from the same context, as required by some UI frameworks. + + + If no SynchronizationContext is present at the point of calling FromEvent, add and remove handler invocations are made synchronously on the thread + making the Subscribe or Dispose call, respectively. + + + It's recommended to lift FromEvent calls outside event stream query expressions due to the free-threaded nature of Reactive Extensions. Doing so + makes the captured SynchronizationContext predictable. This best practice also reduces clutter of bridging code inside queries, making the query expressions + more concise and easier to understand. + + + + + + + Converts an Action-based .NET event to an observable sequence. Each event invocation is surfaced through an OnNext message in the resulting sequence. + For conversion of events conforming to the standard .NET event pattern, use any of the FromEventPattern overloads instead. + + Action that attaches the given event handler to the underlying .NET event. + Action that detaches the given event handler from the underlying .NET event. + The scheduler to run the add and remove event handler logic on. + The observable sequence that contains the event argument objects passed to the invocations of the underlying .NET event. + or or is null. + + + Add and remove handler invocations are made whenever the number of observers grows beyond zero. + As such, an event handler may be shared by multiple simultaneously active observers, using a subject for multicasting. + + + Add and remove handler invocations are run on the specified scheduler. This behavior allows add and remove handler operations for thread-affine events to be + accessed from the same context, as required by some UI frameworks. + + + It's recommended to lift FromEvent calls outside event stream query expressions. This best practice reduces clutter of bridging code inside queries, + making the query expressions more concise and easier to understand. This has additional benefits for overloads of FromEvent that omit the IScheduler + parameter. For more information, see the remarks section on those overloads. + + + + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. The specified seed value is used as the initial accumulator value, + and the specified result selector function is used to select the result value. + + The type of the elements in the source sequence. + The type of the accumulator value. + The type of the resulting value. + An observable sequence to aggregate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + A function to transform the final accumulator value into the result value. + An observable sequence containing a single element with the final accumulator value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Applies an accumulator function over an observable sequence, returning the result of the aggregation as a single element in the result sequence. + For aggregation behavior with incremental intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to aggregate over. + An accumulator function to be invoked on each element. + An observable sequence containing a single element with the final accumulator value. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether all elements of an observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether all elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains any elements. + + The type of the elements in the source sequence. + An observable sequence to check for non-emptiness. + An observable sequence containing a single element determining whether the source sequence contains any elements. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether any element of an observable sequence satisfies a condition. + + The type of the elements in the source sequence. + An observable sequence whose elements to apply the predicate to. + A function to test each element for a condition. + An observable sequence containing a single element determining whether any elements in the source sequence pass the test in the specified predicate. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values. + + A sequence of values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + (Asynchronous) The sum of the elements in the source sequence is larger than . + + + + Computes the average of an observable sequence of nullable values. + + A sequence of nullable values to calculate the average of. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the average of an observable sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values to calculate the average of. + A transform function to apply to each element. + An observable sequence containing a single element with the average of the sequence of values, or null if the source sequence is empty or contains only values that are null. + or is null. + (Asynchronous) The source sequence is empty. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using the default equality comparer. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable sequence contains a specified element by using a specified System.Collections.Generic.IEqualityComparer<T>. + + The type of the elements in the source sequence. + An observable sequence in which to locate a value. + The value to locate in the source sequence. + An equality comparer to compare elements. + An observable sequence containing a single element determining whether the source sequence contains an element that has the specified value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the element at a specified index in a sequence. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence. + is null. + is less than zero. + (Asynchronous) is greater than or equal to the number of elements in the source sequence. + + + + Returns the element at a specified index in a sequence or a default value if the index is out of range. + + The type of the elements in the source sequence. + Observable sequence to return the element from. + The zero-based index of the element to retrieve. + An observable sequence that produces the element at the specified position in the source sequence, or a default value if the index is outside the bounds of the source sequence. + is null. + is less than zero. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the first element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Determines whether an observable sequence is empty. + + The type of the elements in the source sequence. + An observable sequence to check for emptiness. + An observable sequence containing a single element determining whether the source sequence is empty. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence. + is null. + (Asynchronous) The source sequence is empty. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the last element in the observable sequence, or a default value if no such element exists. + is null. + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + Returns an observable sequence containing an that represents the total number of elements in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + An observable sequence containing a single element with the number of elements in the input sequence. + is null. + (Asynchronous) The number of elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns an observable sequence containing an that represents how many elements in the specified observable sequence satisfy a condition. + + The type of the elements in the source sequence. + An observable sequence that contains elements to be counted. + A function to test each element for a condition. + An observable sequence containing a single element with a number that represents how many elements in the input sequence satisfy the condition in the predicate function. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + An observable sequence containing a single element with the maximum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the maximum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of values. + + A sequence of values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the maximum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the maximum value of. + An observable sequence containing a single element with the maximum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the maximum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the maximum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the maximum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the maximum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the maximum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the maximum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the maximum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a maximum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + An observable sequence containing a single element with the minimum element in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum element in an observable sequence according to the specified comparer. + + The type of the elements in the source sequence. + An observable sequence to determine the mimimum element of. + Comparer used to compare elements. + An observable sequence containing a single element with the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of values. + + A sequence of values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the minimum value in an observable sequence of nullable values. + + A sequence of nullable values to determine the minimum value of. + An observable sequence containing a single element with the minimum value in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the objects derived from the elements in the source sequence to determine the minimum of. + An observable sequence to determine the mimimum element of. + A transform function to apply to each element. + Comparer used to compare elements. + An observable sequence containing a single element with the value that corresponds to the minimum element in the source sequence. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Invokes a transform function on each element of a sequence and returns the minimum nullable value. + + The type of the elements in the source sequence. + A sequence of values to determine the minimum value of. + A transform function to apply to each element. + An observable sequence containing a single element with the value of type that corresponds to the minimum value in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the elements in an observable sequence with the minimum key value according to the specified comparer. + + The type of the elements in the source sequence. + The type of the key computed for each element in the source sequence. + An observable sequence to get the minimum elements for. + Key selector function. + Comparer used to compare key values. + An observable sequence containing a list of zero or more elements that have a minimum key value. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether two sequences are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the default equality comparer for their type. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Determines whether an observable and enumerable sequence are equal by comparing the elements pairwise using a specified equality comparer. + + The type of the elements in the source sequence. + First observable sequence to compare. + Second observable sequence to compare. + Comparer used to compare elements of both sequences. + An observable sequence that contains a single element which indicates whether both sequences are of equal length and their corresponding elements are equal according to the specified equality comparer. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Returns the only element of an observable sequence, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence. + is null. + (Asynchronous) The source sequence contains more than one element. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and reports an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate. + or is null. + (Asynchronous) No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + Sequence containing the single element in the observable sequence, or a default value if no such element exists. + is null. + (Asynchronous) The source sequence contains more than one element. + + + + Returns the only element of an observable sequence that matches the predicate, or a default value if no such element exists; this method reports an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + Sequence containing the single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + (Asynchronous) The sequence contains more than one element that satisfies the condition in the predicate. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values. + + A sequence of values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values. + + A sequence of nullable values to calculate the sum of. + An observable sequence containing a single element with the sum of the values in the source sequence. + is null. + (Asynchronous) The sum of the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Computes the sum of a sequence of nullable values that are obtained by invoking a transform function on each element of the input sequence. + + The type of the elements in the source sequence. + A sequence of values that are used to calculate a sum. + A transform function to apply to each element. + An observable sequence containing a single element with the sum of the values in the source sequence. + or is null. + (Asynchronous) The sum of the projected values for the elements in the source sequence is larger than . + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates an array from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get an array of elements for. + An observable sequence containing a single element with an array containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a dictionary from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the dictionary key computed for each element in the source sequence. + The type of the dictionary value computed for each element in the source sequence. + An observable sequence to create a dictionary for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a dictionary mapping unique key values onto the corresponding source sequence's element. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a list from an observable sequence. + + The type of the elements in the source sequence. + The source observable sequence to get a list of elements for. + An observable sequence containing a single element with a list containing all the elements of the source sequence. + is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and a comparer. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Creates a lookup from an observable sequence according to a specified key selector function, a comparer, and an element selector function. + + The type of the elements in the source sequence. + The type of the lookup key computed for each element in the source sequence. + The type of the lookup value computed for each element in the source sequence. + An observable sequence to create a lookup for. + A function to extract a key from each element. + A transform function to produce a result element value from each element. + An equality comparer to compare keys. + An observable sequence containing a single element with a lookup mapping unique key values onto the corresponding source sequence's elements. + or or or is null. + The return type of this operator differs from the corresponding operator on IEnumerable in order to retain asynchronous behavior. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes to the observable sequence, making it hot. + + The type of the elements in the source sequence. + Source sequence to await. + Object that can be awaited. + is null. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes and connects to the observable sequence, making it hot. + + The type of the elements in the source sequence. + Source sequence to await. + Object that can be awaited. + is null. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes to the observable sequence, making it hot. The supplied CancellationToken can be used to cancel the subscription. + + The type of the elements in the source sequence. + Source sequence to await. + Cancellation token. + Object that can be awaited. + is null. + + + + Gets an awaiter that returns the last value of the observable sequence or throws an exception if the sequence is empty. + This operation subscribes and connects to the observable sequence, making it hot. The supplied CancellationToken can be used to cancel the subscription and connection. + + The type of the elements in the source sequence. + Source sequence to await. + Cancellation token. + Object that can be awaited. + is null. + + + + Multicasts the source sequence notifications through the specified subject to the resulting connectable observable. Upon connection of the + connectable observable, the subject is subscribed to the source exactly one, and messages are forwarded to the observers registered with + the connectable observable. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be pushed into the specified subject. + Subject to push source elements into. + A connectable observable sequence that upon connection causes the source sequence to push results into the specified subject. + or is null. + + + + Multicasts the source sequence notifications through an instantiated subject into all uses of the sequence within a selector function. Each + subscription to the resulting sequence causes a separate multicast invocation, exposing the sequence resulting from the selector function's + invocation. For specializations with fixed subject types, see Publish, PublishLast, and Replay. + + The type of the elements in the source sequence. + The type of the elements produced by the intermediate subject. + The type of the elements in the result sequence. + Source sequence which will be multicasted in the specified selector function. + Factory function to create an intermediate subject through which the source sequence's elements will be multicast to the selector function. + Selector function which can use the multicasted source sequence subject to the policies enforced by the created subject. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence. + This operator is a specialization of Multicast using a regular . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all notifications of the source from the time of the subscription on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Initial value received by observers upon subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence and starts with initialValue. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive immediately receive the initial value, followed by all notifications of the source from the time of the subscription on. + Initial value received by observers upon subscription. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will only receive the last notification of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence containing only the last notification. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will only receive the last notification of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + + The type of the elements in the source sequence. + Connectable observable sequence. + An observable sequence that stays connected to the source as long as there is at least one subscription to the observable sequence. + is null. + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + Subscribers will receive all the notifications of the source. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + Subscribers will receive all the notifications of the source. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying all notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying bufferSize notifications. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + A connectable observable sequence that shares a single subscription to the underlying sequence. + is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Returns a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers will be invoked on. + A connectable observable sequence that shares a single subscription to the underlying sequence. + or is null. + is less than zero. + is less than TimeSpan.Zero. + Subscribers will receive all the notifications of the source subject to the specified replay buffer trimming policy. + + + + + Returns an observable sequence that is the result of invoking the selector on a connectable observable sequence that shares a single subscription to the underlying sequence replaying notifications subject to a maximum time length and element count for the replay buffer. + This operator is a specialization of Multicast using a . + + The type of the elements in the source sequence. + The type of the elements in the result sequence. + Source sequence whose elements will be multicasted through a single shared subscription. + Selector function which can use the multicasted source sequence as many times as needed, without causing multiple subscriptions to the source sequence. Subscribers to the given source will receive all the notifications of the source subject to the specified replay buffer trimming policy. + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler where connected observers within the selector function will be invoked on. + An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function. + or or is null. + is less than zero. + is less than TimeSpan.Zero. + + + + + Produces an enumerable sequence of consecutive (possibly empty) chunks of the source sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns consecutive (possibly empty) chunks upon each iteration. + is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create a new collector object. + Merges a sequence element with the current collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or is null. + + + + Produces an enumerable sequence that returns elements collected/aggregated from the source sequence between consecutive iterations. + + The type of the elements in the source sequence. + The type of the elements produced by the merge operation during collection. + Source observable sequence. + Factory to create the initial collector object. + Merges a sequence element with the current collector. + Factory to replace the current collector by a new collector. + The enumerable sequence that returns collected/aggregated elements from the source sequence upon each iteration. + or or or is null. + + + + Returns the first element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the first element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The first element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the first element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The first element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Invokes an action for each element in the observable sequence, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Invokes an action for each element in the observable sequence, incorporating the element's index, and blocks until the sequence is terminated. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + or is null. + Because of its blocking nature, this operator is mainly used for testing. + + + + Returns an enumerator that enumerates all values of the observable sequence. + + The type of the elements in the source sequence. + An observable sequence to get an enumerator for. + The enumerator that can be used to enumerate over the elements in the observable sequence. + is null. + + + + Returns the last element of an observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the last element of an observable sequence, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence, or a default value if no such element exists. + is null. + + + + + Returns the last element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The last element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + + + + + Returns an enumerable sequence whose enumeration returns the latest observed element in the source observable sequence. + Enumerators on the resulting sequence will never produce the same element repeatedly, and will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that returns the last sampled element upon each iteration and subsequently blocks until the next element in the observable source sequence becomes available. + + + + Returns an enumerable sequence whose enumeration returns the most recently observed element in the source observable sequence, using the specified initial value in case no element has been sampled yet. + Enumerators on the resulting sequence never block and can produce the same element repeatedly. + + The type of the elements in the source sequence. + Source observable sequence. + Initial value that will be yielded by the enumerable sequence if no element has been sampled yet. + The enumerable sequence that returns the last sampled element upon each iteration. + is null. + + + + Returns an enumerable sequence whose enumeration blocks until the next element in the source observable sequence becomes available. + Enumerators on the resulting sequence will block until the next element becomes available. + + The type of the elements in the source sequence. + Source observable sequence. + The enumerable sequence that blocks upon each iteration until the next element in the observable source sequence becomes available. + is null. + + + + Returns the only element of an observable sequence, and throws an exception if there is not exactly one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence. + is null. + The source sequence contains more than one element. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, and throws an exception if there is not exactly one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate. + or is null. + No element satisfies the condition in the predicate. -or- More than one element satisfies the condition in the predicate. -or- The source sequence is empty. + + + + + Returns the only element of an observable sequence, or a default value if the observable sequence is empty; this method throws an exception if there is more than one element in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + The single element in the observable sequence, or a default value if no such element exists. + is null. + The source sequence contains more than one element. + + + + + Returns the only element of an observable sequence that satisfies the condition in the predicate, or a default value if no such element exists; this method throws an exception if there is more than one element matching the predicate in the observable sequence. + + The type of the elements in the source sequence. + Source observable sequence. + A predicate function to evaluate for elements in the source sequence. + The single element in the observable sequence that satisfies the condition in the predicate, or a default value if no such element exists. + or is null. + The sequence contains more than one element that satisfies the condition in the predicate. + + + + + Waits for the observable sequence to complete and returns the last element of the sequence. + If the sequence terminates with an OnError notification, the exception is throw. + + The type of the elements in the source sequence. + Source observable sequence. + The last element in the observable sequence. + is null. + The source sequence is empty. + + + + Wraps the source sequence in order to run its observer callbacks on the specified scheduler. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to notify observers on. + The source sequence whose observations happen on the specified scheduler. + or is null. + + This only invokes observer callbacks on a scheduler. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a scheduler, use . + + + + + Wraps the source sequence in order to run its observer callbacks on the specified synchronization context. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to notify observers on. + The source sequence whose observations happen on the specified synchronization context. + or is null. + + This only invokes observer callbacks on a synchronization context. In case the subscription and/or unsubscription actions have side-effects + that require to be run on a synchronization context, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified scheduler. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Scheduler to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified scheduler. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified scheduler. In order to invoke observer + callbacks on a scheduler, use . + + + + + Wraps the source sequence in order to run its subscription and unsubscription logic on the specified synchronization context. This operation is not commonly used; + see the remarks section for more information on the distinction between SubscribeOn and ObserveOn. + + The type of the elements in the source sequence. + Source sequence. + Synchronization context to perform subscription and unsubscription actions on. + The source sequence whose subscriptions and unsubscriptions happen on the specified synchronization context. + or is null. + + This only performs the side-effects of subscription and unsubscription on the specified synchronization context. In order to invoke observer + callbacks on a synchronization context, use . + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently. + This overload is useful to "fix" an observable sequence that exhibits concurrent callbacks on individual observers, which is invalid behavior for the query processor. + + The type of the elements in the source sequence. + Source sequence. + The source sequence whose outgoing calls to observers are synchronized. + is null. + + It's invalid behavior - according to the observer grammar - for a sequence to exhibit concurrent callbacks on a given observer. + This operator can be used to "fix" a source that doesn't conform to this rule. + + + + + Synchronizes the observable sequence such that observer notifications cannot be delivered concurrently, using the specified gate object. + This overload is useful when writing n-ary query operators, in order to prevent concurrent callbacks from different sources by synchronizing on a common gate object. + + The type of the elements in the source sequence. + Source sequence. + Gate object to synchronize each observer call on. + The source sequence whose outgoing calls to observers are synchronized on the given gate object. + or is null. + + + + Subscribes an observer to an enumerable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Disposable object that can be used to unsubscribe the observer from the enumerable + or is null. + + + + Subscribes an observer to an enumerable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to subscribe to. + Observer that will receive notifications from the enumerable sequence. + Scheduler to perform the enumeration on. + Disposable object that can be used to unsubscribe the observer from the enumerable + or or is null. + + + + Converts an observable sequence to an enumerable sequence. + + The type of the elements in the source sequence. + An observable sequence to convert to an enumerable sequence. + The enumerable sequence containing the elements in the observable sequence. + is null. + + + + Exposes an observable sequence as an object with an Action-based .NET event. + + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with an Action<TSource>-based .NET event. + + The type of the elements in the source sequence. + Observable source sequence. + The event source object. + is null. + + + + Exposes an observable sequence as an object with a .NET event, conforming to the standard .NET event pattern. + + The type of the event data generated by the event. + Observable source sequence. + The event source object. + is null. + + + + Converts an enumerable sequence to an observable sequence. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + The observable sequence whose elements are pulled from the given enumerable sequence. + is null. + + + + Converts an enumerable sequence to an observable sequence, using the specified scheduler to run the enumeration loop. + + The type of the elements in the source sequence. + Enumerable sequence to convert to an observable sequence. + Scheduler to run the enumeration of the input sequence on. + The observable sequence whose elements are pulled from the given enumerable sequence. + or is null. + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified Subscribe method implementation. + + The type of the elements in the produced sequence. + Implementation of the resulting observable sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + + Use of this operator is preferred over manual implementation of the IObservable<T> interface. In case + you need a type implementing IObservable<T> rather than an anonymous implementation, consider using + the abstract base class. + + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to produce elements. + The observable sequence surfacing the elements produced by the asynchronous method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to produce elements. + The observable sequence surfacing the elements produced by the asynchronous method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Creates an observable sequence from a specified cancellable asynchronous Subscribe method. + The CancellationToken passed to the asynchronous Subscribe method is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous subscribe function will be signaled. + + + + Creates an observable sequence from a specified asynchronous Subscribe method. + + The type of the elements in the produced sequence. + Asynchronous method used to implemented the resulting sequence's Subscribe method, returning an Action delegate that will be wrapped in an IDisposable. + The observable sequence with the specified implementation for the Subscribe method. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Returns an observable sequence that invokes the specified factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Observable factory function to invoke for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger an invocation of the given observable factory function. + is null. + + + + Returns an observable sequence that starts the specified asynchronous factory function whenever a new observer subscribes. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Asynchronous factory function to start for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger the given asynchronous observable factory function to be started. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + + + + Returns an observable sequence that starts the specified cancellable asynchronous factory function whenever a new observer subscribes. + The CancellationToken passed to the asynchronous factory function is tied to the returned disposable subscription, allowing best-effort cancellation. + + The type of the elements in the sequence returned by the factory function, and in the resulting sequence. + Asynchronous factory function to start for each observer that subscribes to the resulting sequence. + An observable sequence whose observers trigger the given asynchronous observable factory function to be started. + is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous observable factory function will be signaled. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence with no elements. + + + + Returns an empty observable sequence. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + An observable sequence with no elements. + is null. + + + + Returns an empty observable sequence, using the specified scheduler to send out the single OnCompleted message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Scheduler to send the termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence with no elements. + is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + The generated sequence. + or or is null. + + + + Generates an observable sequence by running a state-driven loop producing the sequence's elements, using the specified scheduler to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Scheduler on which to run the generator loop. + The generated sequence. + or or or is null. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + An observable sequence whose observers will never get called. + + + + Returns a non-terminating observable sequence, which can be used to denote an infinite duration (e.g. when using reactive joins). + + The type used for the IObservable<T> type parameter of the resulting sequence. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + An observable sequence whose observers will never get called. + + + + Generates an observable sequence of integral numbers within a specified range. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + + + + Generates an observable sequence of integral numbers within a specified range, using the specified scheduler to send out observer messages. + + The value of the first integer in the sequence. + The number of sequential integers to generate. + Scheduler to run the generator loop on. + An observable sequence that contains a range of sequential integral numbers. + is less than zero. -or- + - 1 is larger than . + is null. + + + + Generates an observable sequence that repeats the given element infinitely. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + An observable sequence that repeats the given element infinitely. + + + + Generates an observable sequence that repeats the given element infinitely, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element infinitely. + is null. + + + + Generates an observable sequence that repeats the given element the specified number of times. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + + + + Generates an observable sequence that repeats the given element the specified number of times, using the specified scheduler to send out observer messages. + + The type of the element that will be repeated in the produced sequence. + Element to repeat. + Number of times to repeat the element. + Scheduler to run the producer loop on. + An observable sequence that repeats the given element the specified number of times. + is less than zero. + is null. + + + + Returns an observable sequence that contains a single element. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + An observable sequence containing the single specified element. + + + + Returns an observable sequence that contains a single element, using the specified scheduler to send out observer messages. + + The type of the element that will be returned in the produced sequence. + Single element in the resulting observable sequence. + Scheduler to send the single element on. + An observable sequence containing the single specified element. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Returns an observable sequence that terminates with an exception, using the specified scheduler to send out the single OnError message. + + The type used for the IObservable<T> type parameter of the resulting sequence. + Exception object used for the sequence's termination. + Scheduler to send the exceptional termination call on. + Object solely used to infer the type of the type parameter. This parameter is typically used when creating a sequence of anonymously typed elements. + The observable sequence that terminates exceptionally with the specified exception object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Factory function to obtain a resource object. + Factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + + + + Constructs an observable sequence that depends on a resource object, whose lifetime is tied to the resulting observable sequence's lifetime. The resource is obtained and used through asynchronous methods. + The CancellationToken passed to the asynchronous methods is tied to the returned disposable subscription, allowing best-effort cancellation at any stage of the resource acquisition or usage. + + The type of the elements in the produced sequence. + The type of the resource used during the generation of the resulting sequence. Needs to implement . + Asynchronous factory function to obtain a resource object. + Asynchronous factory function to obtain an observable sequence that depends on the obtained resource. + An observable sequence whose lifetime controls the lifetime of the dependent resource object. + or is null. + This operator is especially useful in conjunction with the asynchronous programming features introduced in C# 5.0 and Visual Basic 11. + When a subscription to the resulting sequence is disposed, the CancellationToken that was fed to the asynchronous resource factory and observable factory functions will be signaled. + + + + Creates a pattern that matches when both observable sequences have an available element. + + The type of the elements in the left sequence. + The type of the elements in the right sequence. + Observable sequence to match with the right sequence. + Observable sequence to match with the left sequence. + Pattern object that matches when both observable sequences have an available element. + or is null. + + + + Matches when the observable sequence has an available element and projects the element by invoking the selector function. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, returned by the selector function. + Observable sequence to apply the selector on. + Selector that will be invoked for elements in the source sequence. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + or is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results from matching several patterns. + is null. + + + + Joins together the results from several patterns. + + The type of the elements in the result sequence, obtained from the specified patterns. + A series of plans created by use of the Then operator on patterns. + An observable sequence with the results form matching several patterns. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that surfaces either of the given sequences, whichever reacted first. + or is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Propagates the observable sequence that reacts first. + + The type of the elements in the source sequences. + Observable sources competing to react first. + An observable sequence that surfaces any of the given sequences, whichever reacted first. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + A function invoked to define the boundaries of the produced buffers. A new buffer is started when the previous one is closed. + An observable sequence of buffers. + or is null. + + + + Projects each element of an observable sequence into zero or more buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequence indicating buffer opening events, also passed to the closing selector to obtain a sequence of buffer closing events. + The type of the elements in the sequences indicating buffer closing events. + Source sequence to produce buffers over. + Observable sequence whose elements denote the creation of new buffers. + A function invoked to define the closing of each produced buffer. + An observable sequence of buffers. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + The type of the elements in the sequences indicating buffer boundary events. + Source sequence to produce buffers over. + Sequence of buffer boundary markers. The current buffer is closed and a new buffer is opened upon receiving a boundary marker. + An observable sequence of buffers. + or is null. + + + + Continues an observable sequence that is terminated by an exception of the specified type with the observable sequence produced by the handler. + + The type of the elements in the source sequence and sequences returned by the exception handler function. + The type of the exception to catch and handle. Needs to derive from . + Source sequence. + Exception handler function, producing another observable sequence. + An observable sequence containing the source sequence's elements, followed by the elements produced by the handler's resulting observable sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source sequence and handler sequence. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results when an error occurred in the first sequence. + An observable sequence containing the first sequence's elements, followed by the elements of the second sequence in case an exception occurred. + or is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Continues an observable sequence that is terminated by an exception with the next observable sequence. + + The type of the elements in the source and handler sequences. + Observable sequences to catch exceptions for. + An observable sequence containing elements from consecutive source sequences until a source sequence terminates successfully. + is null. + + + + Merges two observable sequences into one observable sequence by using the selector function whenever one of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke whenever either of the sources produces an element. + An observable sequence containing the result of combining elements of both sources using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Sixteenth observable source. + Function to invoke whenever any of the sources produces an element. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke whenever any of the sources produces an element. For efficiency, the input list is reused after the selector returns. Either aggregate or copy the values during the function call. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the latest source elements whenever any of the observable sequences produces an element. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of the latest elements of the sources. + is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful termination of the first. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + An observable sequence that contains the elements of the first sequence, followed by those of the second the sequence. + or is null. + + + + Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that contains the elements of each given sequence, in sequential order. + is null. + + + + Concatenates all inner observable sequences, as long as the previous observable sequence terminated successfully. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + An observable sequence that contains the elements of each observed inner sequence, in sequential order. + is null. + + + + Concatenates all task results, as long as the previous task terminated successfully. + + The type of the results produced by the tasks. + Observable sequence of tasks. + An observable sequence that contains the results of each task, in sequential order. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a concatenation operation using . + + + + Merges elements from all inner observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that merges the elements of the inner sequences. + is null. + + + + Merges results from all source tasks into a single observable sequence. + + The type of the results produced by the source tasks. + Observable sequence of tasks. + The observable sequence that merges the results of the source tasks. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a merge operation using . + + + + Merges elements from all inner observable sequences into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + Maximum number of inner observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the inner sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + The observable sequence that merges the elements of the observable sequences. + is null. + is less than or equal to zero. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, limiting the number of concurrent subscriptions to inner sequences, and using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Maximum number of observable sequences being subscribed to concurrently. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + is less than or equal to zero. + + + + Merges elements from two observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + The observable sequence that merges the elements of the given sequences. + or is null. + + + + Merges elements from two observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + First observable sequence. + Second observable sequence. + Scheduler used to introduce concurrency for making subscriptions to the given sequences. + The observable sequence that merges the elements of the given sequences. + or or is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence. + + The type of the elements in the source sequences. + Observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all of the specified observable sequences into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + The observable sequence that merges the elements of the observable sequences. + is null. + + + + Merges elements from all observable sequences in the given enumerable sequence into a single observable sequence, using the specified scheduler for enumeration of and subscription to the sources. + + The type of the elements in the source sequences. + Enumerable sequence of observable sequences. + Scheduler to run the enumeration of the sequence of sources on. + The observable sequence that merges the elements of the observable sequences. + or is null. + + + + Concatenates the second observable sequence to the first observable sequence upon successful or exceptional termination of the first. + + The type of the elements in the source sequences. + First observable sequence whose exception (if any) is caught. + Second observable sequence used to produce results after the first sequence terminates. + An observable sequence that concatenates the first and second sequence, even if the first sequence terminates exceptionally. + or is null. + + + + Concatenates all of the specified observable sequences, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Concatenates all observable sequences in the given enumerable sequence, even if the previous observable sequence terminated exceptionally. + + The type of the elements in the source sequences. + Observable sequences to concatenate. + An observable sequence that concatenates the source sequences, even if a sequence terminates exceptionally. + is null. + + + + Returns the elements from the source observable sequence only after the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of skip behavior. + Source sequence to propagate elements for. + Observable sequence that triggers propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence starting from the point the other sequence triggered propagation. + or is null. + + + + Switches between the inner observable sequences such that the resulting sequence always produces elements from the most recently received inner observable sequence. + Each time a new inner observable sequence is received, the previous inner observable sequence is unsubscribed from. + + The type of the elements in the source sequences. + Observable sequence of inner observable sequences. + The observable sequence that at any point in time produces the elements of the most recent inner observable sequence that has been received. + is null. + + + + Switches between the tasks such that the resulting sequence always produces results from the most recently received task. + Each time a new task is received, the previous task's result is ignored. + + The type of the results produced by the source tasks. + Observable sequence of tasks. + The observable sequence that at any point in time produces the result of the most recent task that has been received. + is null. + If the tasks support cancellation, consider manual conversion of the tasks using , followed by a switch operation using . + + + + Returns the elements from the source observable sequence until the other observable sequence produces an element. + + The type of the elements in the source sequence. + The type of the elements in the other sequence that indicates the end of take behavior. + Source sequence to propagate elements for. + Observable sequence that terminates propagation of elements of the source sequence. + An observable sequence containing the elements of the source sequence up to the point the other sequence interrupted further propagation. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + A function invoked to define the boundaries of the produced windows. A new window is started when the previous one is closed. + An observable sequence of windows. + or is null. + + + + Projects each element of an observable sequence into zero or more windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequence indicating window opening events, also passed to the closing selector to obtain a sequence of window closing events. + The type of the elements in the sequences indicating window closing events. + Source sequence to produce windows over. + Observable sequence whose elements denote the creation of new windows. + A function invoked to define the closing of each produced window. + An observable sequence of windows. + or or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows. + + The type of the elements in the source sequence, and in the windows in the result sequence. + The type of the elements in the sequences indicating window boundary events. + Source sequence to produce windows over. + Sequence of window boundary markers. The current window is closed and a new window is opened upon receiving a boundary marker. + An observable sequence of windows. + or is null. + + + + Merges two observable sequences into one observable sequence by combining their elements in a pairwise fashion. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second observable source. + Third observable source. + Fourth observable source. + Fifth observable source. + Sixth observable source. + Seventh observable source. + Eighth observable source. + Ninth observable source. + Tenth observable source. + Eleventh observable source. + Twelfth observable source. + Thirteenth observable source. + Fourteenth observable source. + Fifteenth observable source. + Sixteenth observable source. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or or or or or or or or or or or or or or or or is null. + + + + Merges the specified observable sequences into one observable sequence by using the selector function whenever all of the observable sequences have produced an element at a corresponding index. + + The type of the elements in the source sequences. + The type of the elements in the result sequence, returned by the selector function. + Observable sources. + Function to invoke for each series of elements at corresponding indexes in the sources. + An observable sequence containing the result of combining elements of the sources using the specified result selector function. + or is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges the specified observable sequences into one observable sequence by emitting a list with the elements of the observable sequences at corresponding indexes. + + The type of the elements in the source sequences, and in the lists in the result sequence. + Observable sources. + An observable sequence containing lists of elements at corresponding indexes. + is null. + + + + Merges an observable sequence and an enumerable sequence into one observable sequence by using the selector function. + + The type of the elements in the first observable source sequence. + The type of the elements in the second enumerable source sequence. + The type of the elements in the result sequence, returned by the selector function. + First observable source. + Second enumerable source. + Function to invoke for each consecutive pair of elements from the first and second source. + An observable sequence containing the result of pairwise combining the elements of the first and second source using the specified result selector function. + or or is null. + + + + Hides the identity of an observable sequence. + + The type of the elements in the source sequence. + An observable sequence whose identity to hide. + An observable sequence that hides the identity of the source sequence. + is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on element count information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Number of elements to skip between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than or equal to zero. + + + + Dematerializes the explicit notification values of an observable sequence as implicit notifications. + + The type of the elements materialized in the source sequence notification objects. + An observable sequence containing explicit notification values which have to be turned into implicit notifications. + An observable sequence exhibiting the behavior corresponding to the source sequence's notification values. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + An observable sequence only containing the distinct contiguous elements from the source sequence. + is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct contiguous elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct contiguous elements from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or is null. + + + + Returns an observable sequence that contains only distinct contiguous elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct contiguous elements for, based on a computed key value. + A function to compute the comparison key for each element. + Equality comparer for computed key values. + An observable sequence only containing the distinct contiguous elements, based on a computed key value, from the source sequence. + or or is null. + + + + Invokes an action for each element in the observable sequence, and propagates all observer messages through the result sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or is null. + + + + Invokes an action for each element in the observable sequence and invokes an action upon graceful or exceptional termination of the observable sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke for each element in the observable sequence. + Action to invoke upon exceptional termination of the observable sequence. + Action to invoke upon graceful termination of the observable sequence. + The source sequence with the side-effecting behavior applied. + or or or is null. + + + + Invokes the observer's methods for each message in the source sequence. + This method can be used for debugging, logging, etc. of query behavior by intercepting the message stream to run arbitrary actions for messages on the pipeline. + + The type of the elements in the source sequence. + Source sequence. + Observer whose methods to invoke as part of the source sequence's observation. + The source sequence with the side-effecting behavior applied. + or is null. + + + + Invokes a specified action after the source observable sequence terminates gracefully or exceptionally. + + The type of the elements in the source sequence. + Source sequence. + Action to invoke after the source observable sequence terminates. + Source sequence with the action-invoking termination behavior applied. + or is null. + + + + Ignores all elements in an observable sequence leaving only the termination messages. + + The type of the elements in the source sequence. + Source sequence. + An empty observable sequence that signals termination, successful or exceptional, of the source sequence. + is null. + + + + Materializes the implicit notifications of an observable sequence as explicit notification values. + + The type of the elements in the source sequence. + An observable sequence to get notification values for. + An observable sequence containing the materialized notification values from the source sequence. + is null. + + + + Repeats the observable sequence indefinitely. + + The type of the elements in the source sequence. + Observable sequence to repeat. + The observable sequence producing the elements of the given sequence repeatedly and sequentially. + is null. + + + + Repeats the observable sequence a specified number of times. + + The type of the elements in the source sequence. + Observable sequence to repeat. + Number of times to repeat the sequence. + The observable sequence producing the elements of the given sequence repeatedly. + is null. + is less than zero. + + + + Repeats the source observable sequence until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + + + + Repeats the source observable sequence the specified number of times or until it successfully terminates. + + The type of the elements in the source sequence. + Observable sequence to repeat until it successfully terminates. + Number of times to repeat the sequence. + An observable sequence producing the elements of the given sequence repeatedly until it terminates successfully. + is null. + is less than zero. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. The specified seed value is used as the initial accumulator value. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence. + The type of the result of the aggregation. + An observable sequence to accumulate over. + The initial accumulator value. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Applies an accumulator function over an observable sequence and returns each intermediate result. + For aggregation behavior with no intermediate results, see . + + The type of the elements in the source sequence and the result of the aggregation. + An observable sequence to accumulate over. + An accumulator function to be invoked on each element. + An observable sequence containing the accumulated values. + or is null. + + + + Bypasses a specified number of elements at the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to bypass at the end of the source sequence. + An observable sequence containing the source sequence elements except for the bypassed ones at the end. + is null. + is less than zero. + + This operator accumulates a queue with a length enough to store the first elements. As more elements are + received, elements are taken from the front of the queue and produced on the result sequence. This causes elements to be delayed. + + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Prepends a sequence of values to an observable sequence. + + The type of the elements in the source sequence. + Source sequence to prepend values to. + Scheduler to emit the prepended values on. + Values to prepend to the specified sequence. + The source sequence prepended with the specified values. + or or is null. + + + + Returns a specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a specified number of contiguous elements from the end of an observable sequence, using the specified scheduler to drain the queue. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + Scheduler used to drain the queue upon completion of the source sequence. + An observable sequence containing the specified number of elements from the end of the source sequence. + or is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements elements. Upon completion of + the source sequence, this buffer is drained on the result sequence. This causes the elements to be delayed. + + + + + Returns a list with the specified number of contiguous elements from the end of an observable sequence. + + The type of the elements in the source sequence. + Source sequence. + Number of elements to take from the end of the source sequence. + An observable sequence containing a single list with the specified number of elements from the end of the source sequence. + is null. + is less than zero. + + This operator accumulates a buffer with a length enough to store elements. Upon completion of the + source sequence, this buffer is produced on the result sequence. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + An observable sequence of windows. + is null. + is less than or equal to zero. + + + + Projects each element of an observable sequence into zero or more windows which are produced based on element count information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Number of elements to skip between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than or equal to zero. + + + + Converts the elements of an observable sequence to the specified type. + + The type to convert the elements in the source sequence to. + The observable sequence that contains the elements to be converted. + An observable sequence that contains each element of the source sequence converted to the specified type. + is null. + + + + Returns the elements of the specified sequence or the type parameter's default value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), whose default value will be taken if the sequence is empty. + The sequence to return a default value for if it is empty. + An observable sequence that contains the default value for the TSource type if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns the elements of the specified sequence or the specified value in a singleton sequence if the sequence is empty. + + The type of the elements in the source sequence (if any), and the specified default value which will be taken if the sequence is empty. + The sequence to return the specified value for if it is empty. + The value to return if the sequence is empty. + An observable sequence that contains the specified default value if the source is empty; otherwise, the elements of the source itself. + is null. + + + + Returns an observable sequence that contains only distinct elements. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + An observable sequence only containing the distinct elements from the source sequence. + is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the comparer. + + The type of the elements in the source sequence. + An observable sequence to retain distinct elements for. + Equality comparer for source elements. + An observable sequence only containing the distinct elements from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Returns an observable sequence that contains only distinct elements according to the keySelector and the comparer. + + The type of the elements in the source sequence. + The type of the discriminator key computed for each element in the source sequence. + An observable sequence to retain distinct elements for. + A function to compute the comparison key for each element. + Equality comparer for source elements. + An observable sequence only containing the distinct elements, based on a computed key value, from the source sequence. + or or is null. + Usage of this operator should be considered carefully due to the maintenance of an internal lookup structure which can grow large. + + + + Groups the elements of an observable sequence according to a specified key selector function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + An equality comparer to compare keys with. + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encountered. + + or or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and selects the resulting elements by using a specified function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements within the groups computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to map each source element to an element in an observable group. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function and comparer. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + An equality comparer to compare keys with. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or or is null. + + + + Groups the elements of an observable sequence according to a specified key selector function. + A duration selector function is used to control the lifetime of groups. When a group expires, it receives an OnCompleted notification. When a new element with the same + key value as a reclaimed group occurs, the group will be reborn with a new lifetime request. + + The type of the elements in the source sequence. + The type of the grouping key computed for each element in the source sequence. + The type of the elements in the duration sequences obtained for each group to denote its lifetime. + An observable sequence whose elements to group. + A function to extract the key for each element. + A function to signal the expiration of a group. + + A sequence of observable groups, each of which corresponds to a unique key value, containing all elements that share that same key value. + If a group's lifetime expires, a new group with the same key value can be created once an element with such a key value is encoutered. + + or or is null. + + + + Correlates the elements of two sequences based on overlapping durations, and groups the results. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any element of the left sequence with overlapping elements from the right observable sequence. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Correlates the elements of two sequences based on overlapping durations. + + The type of the elements in the left source sequence. + The type of the elements in the right source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the left source sequence. + The type of the elements in the duration sequence denoting the computed duration of each element in the right source sequence. + The type of the elements in the result sequence, obtained by invoking the result selector function for source elements with overlapping duration. + The left observable sequence to join elements for. + The right observable sequence to join elements for. + A function to select the duration of each element of the left observable sequence, used to determine overlap. + A function to select the duration of each element of the right observable sequence, used to determine overlap. + A function invoked to compute a result element for any two overlapping elements of the left and right observable sequences. + An observable sequence that contains result elements computed from source elements that have an overlapping duration. + or or or or is null. + + + + Filters the elements of an observable sequence based on the specified type. + + The type to filter the elements in the source sequence on. + The observable sequence that contains the elements to be filtered. + An observable sequence that contains elements from the input sequence of type TResult. + is null. + + + + Projects each element of an observable sequence into a new form. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of an observable sequence into a new form by incorporating the element's index. + + The type of the elements in the source sequence. + The type of the elements in the result sequence, obtained by running the selector function for each element in the source sequence. + A sequence of elements to invoke a transform function on. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the transform function on each element of source. + or is null. + + + + Projects each element of the source observable sequence to the other observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the other sequence and the elements in the result sequence. + An observable sequence of elements to project. + An observable sequence to project each element from the source sequence onto. + An observable sequence whose elements are the result of projecting each source element onto the other sequence and merging all the resulting sequences together. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + + + + Projects each element of an observable sequence to a task and merges all of the task results into one observable sequence. + + The type of the elements in the source sequence. + The type of the result produced by the projected tasks and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of the tasks executed for each element of the input sequence. + This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + or is null. + + + + Projects each element of an observable sequence to a task with cancellation support and merges all of the task results into one observable sequence. + + The type of the elements in the source sequence. + The type of the result produced by the projected tasks and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of the tasks executed for each element of the input sequence. + This overload supports composition of observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to an observable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + + + + Projects each element of an observable sequence to a task, invokes the result selector for the source element and the task result, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the results produced by the projected intermediate tasks. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate task results. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element. + or or is null. + This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + + + + Projects each element of an observable sequence to a task with cancellation support, invokes the result selector for the source element and the task result, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the results produced by the projected intermediate tasks. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate task results. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of obtaining a task for each element of the input sequence and then mapping the task's result and its corresponding source element to a result element. + or or is null. + This overload supports using LINQ query comprehension syntax in C# and Visual Basic to compose observable sequences and tasks, without requiring manual conversion of the tasks to observable sequences using . + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element. + A transform function to apply when an error occurs in the source sequence. + A transform function to apply when the end of the source sequence is reached. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner sequences and the elements in the merged result sequence. + An observable sequence of notifications to project. + A transform function to apply to each element; the second parameter represents the index of the source element. + A transform function to apply when an error occurs in the source sequence; the second parameter represents the index of the source element. + A transform function to apply when the end of the source sequence is reached; the second parameter represents the number of elements observed. + An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence. + or or or is null. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence and concatenates the resulting enumerable sequences into one observable sequence. + The index of each source element is used in the projected form of that element. + + The type of the elements in the source sequence. + The type of the elements in the projected inner enumerable sequences and the elements in the merged result sequence. + An observable sequence of elements to project. + A transform function to apply to each source element; the second parameter of the function represents the index of the source element. + An observable sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence. + or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Projects each element of an observable sequence to an enumerable sequence, invokes the result selector for the source element and each of the corresponding inner sequence's elements, and merges the results into one observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the projected intermediate enumerable sequences. + The type of the elements in the result sequence, obtained by using the selector to combine source sequence elements with their corresponding intermediate sequence elements. + An observable sequence of elements to project. + A transform function to apply to each element; the second parameter of the function represents the index of the source element. + A transform function to apply to each element of the intermediate sequence. + An observable sequence whose elements are the result of invoking the one-to-many transform function collectionSelector on each element of the input sequence and then mapping each of those sequence elements and their corresponding source element to a result element. + or or is null. + The projected sequences are enumerated synchonously within the OnNext call of the source sequence. In order to do a concurrent, non-blocking merge, change the selector to return an observable sequence obtained using the conversion. + + + + Bypasses a specified number of elements in an observable sequence and then returns the remaining elements. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to skip before returning the remaining elements. + An observable sequence that contains the elements that occur after the specified index in the input sequence. + is null. + is less than zero. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Bypasses elements in an observable sequence as long as a specified condition is true and then returns the remaining elements. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + An observable sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate. + or is null. + + + + Returns a specified number of contiguous elements from the start of an observable sequence. + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + An observable sequence that contains the specified number of elements from the start of the input sequence. + is null. + is less than zero. + + + + Returns a specified number of contiguous elements from the start of an observable sequence, using the specified scheduler for the edge case of Take(0). + + The type of the elements in the source sequence. + The sequence to take elements from. + The number of elements to return. + Scheduler used to produce an OnCompleted message in case count is set to 0. + An observable sequence that contains the specified number of elements from the start of the input sequence. + or is null. + is less than zero. + + + + Returns elements from an observable sequence as long as a specified condition is true. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Returns elements from an observable sequence as long as a specified condition is true. + The element's index is used in the logic of the predicate function. + + The type of the elements in the source sequence. + A sequence to return elements from. + A function to test each element for a condition; the second parameter of the function represents the index of the source element. + An observable sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes. + or is null. + + + + Filters the elements of an observable sequence based on a predicate. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a condition. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Filters the elements of an observable sequence based on a predicate by incorporating the element's index. + + The type of the elements in the source sequence. + An observable sequence whose elements to filter. + A function to test each source element for a conditio; the second parameter of the function represents the index of the source element. + An observable sequence that contains elements from the input sequence that satisfy the condition. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + An observable sequence of buffers. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more buffers which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Length of each buffer. + Interval between creation of consecutive buffers. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers with minimum duration + length. However, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + However, this doesn't mean all buffers will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of buffers. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a buffer that's sent out when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the lists in the result sequence. + Source sequence to produce buffers over. + Maximum time length of a buffer. + Maximum element count of a buffer. + Scheduler to run buffering timers on. + An observable sequence of buffers. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create buffers as fast as it can. + Because all source sequence elements end up in one of the buffers, some buffers won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current buffer and to create a new buffer may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Time shifts the observable sequence by the specified relative time duration. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence by the specified relative time duration, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Relative time by which to shift the observable sequence. If this value is equal to TimeSpan.Zero, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Time-shifted sequence. + is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the default scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence to start propagating notifications at the specified absolute time, using the specified scheduler to run timers. + The relative time intervals between the values are preserved. + + The type of the elements in the source sequence. + Source sequence to delay values for. + Absolute time used to shift the observable sequence; the relative time shift gets computed upon subscription. If this value is less than or equal to DateTimeOffset.UtcNow, the scheduler will dispatch observer callbacks as soon as possible. + Scheduler to run the delay timers on. + Time-shifted sequence. + or is null. + + + This operator is less efficient than DelaySubscription because it records all notifications and time-delays those. This allows for immediate propagation of errors. + + + Observer callbacks for the resulting sequence will be run on the specified scheduler. This effect is similar to using ObserveOn. + + + Exceptions signaled by the source sequence through an OnError callback are forwarded immediately to the result sequence. Any OnNext notifications that were in the queue at the point of the OnError callback will be dropped. + In order to delay error propagation, consider using the Observable.Materialize and Observable.Dematerialize operators, or use DelaySubscription. + + + + + + Time shifts the observable sequence based on a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or is null. + + + + Time shifts the observable sequence based on a subscription delay and a delay selector function for each element. + + The type of the elements in the source sequence. + The type of the elements in the delay sequences used to denote the delay duration of each element in the source sequence. + Source sequence to delay values for. + Sequence indicating the delay for the subscription to the source. + Selector function to retrieve a sequence indicating the delay for each given element. + Time-shifted sequence. + or or is null. + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Time-shifted sequence. + is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription with the specified relative time duration, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Relative time shift of the subscription. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Time-shifted sequence. + is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the default scheduler. Observer callbacks will not be affected. + + + + + + Time shifts the observable sequence by delaying the subscription to the specified absolute time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to delay subscription for. + Absolute time to perform the subscription at. + Scheduler to run the subscription delay timer on. + Time-shifted sequence. + or is null. + + + This operator is more efficient than Delay but postpones all side-effects of subscription and affects error propagation timing. + + + The side-effects of subscribing to the source sequence will be run on the specified scheduler. Observer callbacks will not be affected. + + + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + The generated sequence. + or or or is null. + + + + Generates an observable sequence by running a state-driven and temporal loop producing the sequence's elements, using the specified scheduler to run timers and to send out observer messages. + + The type of the state used in the generator loop. + The type of the elements in the produced sequence. + Initial state. + Condition to terminate generation (upon returning false). + Iteration step function. + Selector function for results produced in the sequence. + Time selector function to control the speed of values being produced each iteration. + Scheduler on which to run the generator loop. + The generated sequence. + or or or or is null. + + + + Returns an observable sequence that produces a value after each period. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Returns an observable sequence that produces a value after each period, using the specified scheduler to run timers and to send out observer messages. + + Period for producing the values in the resulting sequence. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after each period. + is less than TimeSpan.Zero. + is null. + + Intervals are measured between the start of subsequent notifications, not between the end of the previous and the start of the next notification. + If the observer takes longer than the interval period to handle the message, the subsequent notification will be delivered immediately after the + current one has been handled. In case you need to control the time between the end and the start of consecutive notifications, consider using the + + operator instead. + + + + + Samples the observable sequence at each interval. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Sampled observable sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the observable sequence at each interval, using the specified scheduler to run sampling timers. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + Source sequence to sample. + Interval at which to sample. If this value is equal to TimeSpan.Zero, the scheduler will continuously sample the stream. + Scheduler to run the sampling timer on. + Sampled observable sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee all source sequence elements will be preserved. This is a side-effect + of the asynchrony introduced by the scheduler, where the sampling action may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Samples the source observable sequence using a samper observable sequence producing sampling ticks. + Upon each sampling tick, the latest element (if any) in the source sequence during the last sampling interval is sent to the resulting sequence. + + The type of the elements in the source sequence. + The type of the elements in the sampling sequence. + Source sequence to sample. + Sampling tick sequence. + Sampled observable sequence. + or is null. + + + + Skips elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for doesn't guarantee no elements will be dropped from the start of the source sequence. + This is a side-effect of the asynchrony introduced by the scheduler, where the action that causes callbacks from the source sequence to be forwarded + may not execute immediately, despite the TimeSpan.Zero due time. + + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + + Skips elements for the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements for the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Duration for skipping elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements skipped during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a queue with a length enough to store elements received during the initial window. + As more elements are received, elements older than the specified are taken from the queue and produced on the + result sequence. This causes elements to be delayed with . + + + + + Skips elements from the observable source sequence until the specified start time. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + An observable sequence with the elements skipped until the specified start time. + is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Skips elements from the observable source sequence until the specified start time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to skip elements for. + Time to start taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, no elements will be skipped. + Scheduler to run the timer on. + An observable sequence with the elements skipped until the specified start time. + or is null. + + Errors produced by the source sequence are always forwarded to the result sequence, even if the error occurs before the . + + + + + Takes elements for the specified duration from the start of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Takes elements for the specified duration from the start of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the start of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the start of the source sequence. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for doesn't guarantee an empty sequence will be returned. This is a side-effect + of the asynchrony introduced by the scheduler, where the action that stops forwarding callbacks from the source sequence may not execute + immediately, despite the TimeSpan.Zero due time. + + + + + Returns elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns elements within the specified duration from the end of the observable source sequence, using the specified schedulers to run timers and to drain the collected elements. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + Scheduler to drain the collected elements. + An observable sequence with the elements taken during the specified duration from the end of the source sequence. + or or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is drained on the result sequence. This causes the result elements + to be delayed with . + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Returns a list with the elements within the specified duration from the end of the observable source sequence, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Duration for taking elements from the end of the sequence. + Scheduler to run the timer on. + An observable sequence containing a single list with the elements taken during the specified duration from the end of the source sequence. + or is null. + is less than TimeSpan.Zero. + + This operator accumulates a buffer with a length enough to store elements for any window during the lifetime of + the source sequence. Upon completion of the source sequence, this buffer is produced on the result sequence. + + + + + Takes elements for the specified duration until the specified end time. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + An observable sequence with the elements taken until the specified end time. + is null. + + + + Takes elements for the specified duration until the specified end time, using the specified scheduler to run timers. + + The type of the elements in the source sequence. + Source sequence to take elements from. + Time to stop taking elements from the source sequence. If this value is less than or equal to DateTimeOffset.UtcNow, the result stream will complete immediately. + Scheduler to run the timer on. + An observable sequence with the elements taken until the specified end time. + or is null. + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + The throttled sequence. + is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another element within a specified relative time duration, using the specified scheduler to run throttling timers. + + The type of the elements in the source sequence. + Source sequence to throttle. + Throttling duration for each element. + Scheduler to run the throttle timers on. + The throttled sequence. + or is null. + is less than TimeSpan.Zero. + + + This operator throttles the source sequence by holding on to each element for the duration specified in . If another + element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this whole + process. For streams that never have gaps larger than or equal to between elements, the resulting stream won't + produce any elements. In order to reduce the volume of a stream whilst guaranteeing the periodic production of elements, consider using the + Observable.Sample set of operators. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing throttling timers to be scheduled + that are due immediately. However, this doesn't guarantee all elements will be retained in the result sequence. This is a side-effect of the + asynchrony introduced by the scheduler, where the action to forward the current element may not execute immediately, despite the TimeSpan.Zero + due time. In such cases, the next element may arrive before the scheduler gets a chance to run the throttling action. + + + + + + Ignores elements from an observable sequence which are followed by another value within a computed throttle duration. + + The type of the elements in the source sequence. + The type of the elements in the throttle sequences selected for each element in the source sequence. + Source sequence to throttle. + Selector function to retrieve a sequence indicating the throttle duration for each given element. + The throttled sequence. + or is null. + + This operator throttles the source sequence by holding on to each element for the duration denoted by . + If another element is produced within this time window, the element is dropped and a new timer is started for the current element, repeating this + whole process. For streams where the duration computed by applying the to each element overlaps with + the occurrence of the successor element, the resulting stream won't produce any elements. In order to reduce the volume of a stream whilst + guaranteeing the periodic production of elements, consider using the Observable.Sample set of operators. + + + + + Records the time interval between consecutive elements in an observable sequence. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + An observable sequence with time interval information on elements. + is null. + + + + Records the time interval between consecutive elements in an observable sequence, using the specified scheduler to compute time intervals. + + The type of the elements in the source sequence. + Source sequence to record time intervals for. + Scheduler used to compute time intervals. + An observable sequence with time interval information on elements. + or is null. + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + The source sequence with a TimeoutException in case of a timeout. + is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + is less than TimeSpan.Zero. + (Asynchronous) If no element is produced within from the previous element. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy for each element in the observable sequence, using the specified scheduler to run timeout timers. + If the next element isn't received within the specified timeout duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Maximum duration between values before a timeout occurs. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + is less than TimeSpan.Zero. + + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing timeout timers to be scheduled that are due + immediately. However, this doesn't guarantee a timeout will occur, even for the first element. This is a side-effect of the asynchrony introduced by the + scheduler, where the action to propagate a timeout may not execute immediately, despite the TimeSpan.Zero due time. In such cases, the next element may + arrive before the scheduler gets a chance to run the timeout action. + + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + The source sequence with a TimeoutException in case of a timeout. + is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Scheduler to run the timeout timers on. + The source sequence with a TimeoutException in case of a timeout. + or is null. + (Asynchronous) If the sequence hasn't terminated before . + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on an absolute time, using the specified scheduler to run timeout timers. + If the sequence doesn't terminate before the specified absolute due time, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + Source sequence to perform a timeout for. + Time when a timeout occurs. If this value is less than or equal to DateTimeOffset.UtcNow, the timeout occurs immediately. + Sequence to return in case of a timeout. + Scheduler to run the timeout timers on. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + In case you only want to timeout on the first element, consider using the + operator applied to the source sequence and a delayed sequence. Alternatively, the general-purpose overload + of Timeout, can be used. + + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or is null. + + + + Applies a timeout policy to the observable sequence based on a timeout duration computed for each element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, a TimeoutException is propagated to the observer. + + The type of the elements in the source sequence. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + The source sequence with a TimeoutException in case of a timeout. + or or is null. + + + + Applies a timeout policy to the observable sequence based on an initial timeout duration for the first element, and a timeout duration computed for each subsequent element. + If the next element isn't received within the computed duration starting from its predecessor, the other observable sequence is used to produce future messages from that point on. + + The type of the elements in the source sequence and the other sequence used upon a timeout. + The type of the elements in the timeout sequences used to indicate the timeout duration for each element in the source sequence. + Source sequence to perform a timeout for. + Observable sequence that represents the timeout for the first element. + Selector to retrieve an observable sequence that represents the timeout between the current element and the next element. + Sequence to return in case of a timeout. + The source sequence switching to the other sequence in case of a timeout. + or or or is null. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + An observable sequence that produces a value after the due time has elapsed. + + + + Returns an observable sequence that produces a single value at the specified absolute due time. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + An observable sequence that produces a value at due time. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value after due time has elapsed and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + + + + Returns an observable sequence that produces a single value after the specified relative due time has elapsed, using the specified scheduler to run the timer. + + Relative time at which to produce the value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value after the due time has elapsed. + is null. + + + + Returns an observable sequence that produces a single value at the specified absolute due time, using the specified scheduler to run the timer. + + Absolute time at which to produce the value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Scheduler to run the timer on. + An observable sequence that produces a value at due time. + is null. + + + + Returns an observable sequence that periodically produces a value after the specified initial relative due time has elapsed, using the specified scheduler to run timers. + + Relative time at which to produce the first value. If this value is less than or equal to TimeSpan.Zero, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value after due time has elapsed and then each period. + is less than TimeSpan.Zero. + is null. + + + + Returns an observable sequence that periodically produces a value starting at the specified initial absolute due time, using the specified scheduler to run timers. + + Absolute time at which to produce the first value. If this value is less than or equal to DateTimeOffset.UtcNow, the timer will fire as soon as possible. + Period to produce subsequent values. If this value is equal to TimeSpan.Zero, the timer will recur as fast as possible. + Scheduler to run timers on. + An observable sequence that produces a value at due time and then after each period. + is less than TimeSpan.Zero. + is null. + + + + Timestamps each element in an observable sequence using the local system clock. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + An observable sequence with timestamp information on elements. + is null. + + + + Timestamp each element in an observable sequence using the clock of the specified scheduler. + + The type of the elements in the source sequence. + Source sequence to timestamp elements for. + Scheduler used to compute timestamps. + An observable sequence with timestamp information on elements. + or is null. + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + The sequence of windows. + is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into consecutive non-overlapping windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + An observable sequence of windows. + is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into zero or more windows which are produced based on timing information, using the specified scheduler to run timers. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Length of each window. + Interval between creation of consecutive windows. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + or is less than TimeSpan.Zero. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows with minimum duration + length. However, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced by the scheduler, where the action to close the + current window may not execute immediately, despite the TimeSpan.Zero due time. + + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + However, this doesn't mean all windows will start at the beginning of the source sequence. This is a side-effect of the asynchrony introduced by the scheduler, + where the action to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + An observable sequence of windows. + is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Projects each element of an observable sequence into a window that is completed when either it's full or a given amount of time has elapsed, using the specified scheduler to run timers. + A useful real-world analogy of this overload is the behavior of a ferry leaving the dock when all seats are taken, or at the scheduled time of departure, whichever event occurs first. + + The type of the elements in the source sequence, and in the windows in the result sequence. + Source sequence to produce windows over. + Maximum time length of a window. + Maximum element count of a window. + Scheduler to run windowing timers on. + An observable sequence of windows. + or is null. + is less than TimeSpan.Zero. -or- is less than or equal to zero. + + Specifying a TimeSpan.Zero value for is not recommended but supported, causing the scheduler to create windows as fast as it can. + Because all source sequence elements end up in one of the windows, some windows won't have a zero time span. This is a side-effect of the asynchrony introduced + by the scheduler, where the action to close the current window and to create a new window may not execute immediately, despite the TimeSpan.Zero due time. + + + + + Internal interface describing the LINQ to Events query language. + + + + + Base class for classes that expose an observable sequence as a well-known event pattern (sender, event arguments). + Contains functionality to maintain a map of event handler delegates to observable sequence subscriptions. Subclasses + should only add an event with custom add and remove methods calling into the base class's operations. + + The type of the sender that raises the event. + The type of the event data generated by the event. + + + + Creates a new event pattern source. + + Source sequence to expose as an event. + Delegate used to invoke the event for each element of the sequence. + or is null. + + + + Adds the specified event handler, causing a subscription to the underlying source. + + Event handler to add. The same delegate should be passed to the Remove operation in order to remove the event handler. + Invocation delegate to raise the event in the derived class. + or is null. + + + + Removes the specified event handler, causing a disposal of the corresponding subscription to the underlying source that was created during the Add operation. + + Event handler to remove. This should be the same delegate as one that was passed to the Add operation. + is null. + + + + Represents a .NET event invocation consisting of the weakly typed object that raised the event and the data that was generated by the event. + + The type of the event data generated by the event. + + + + Represents a .NET event invocation consisting of the strongly typed object that raised the event and the data that was generated by the event. + + The type of the sender that raised the event. + The type of the event data generated by the event. + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Determines whether the current EventPattern<TSender, TEventArgs> object represents the same event as a specified EventPattern<TSender, TEventArgs> object. + + An object to compare to the current EventPattern<TSender, TEventArgs> object. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>. + + The System.Object to compare with the current EventPattern<TSender, TEventArgs>. + true if the specified System.Object is equal to the current EventPattern<TSender, TEventArgs>; otherwise, false. + + + + Returns the hash code for the current EventPattern<TSender, TEventArgs> instance. + + A hash code for the current EventPattern<TSender, TEventArgs> instance. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent the same event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects represent the same event; otherwise, false. + + + + Determines whether two specified EventPattern<TSender, TEventArgs> objects represent a different event. + + The first EventPattern<TSender, TEventArgs> to compare, or null. + The second EventPattern<TSender, TEventArgs> to compare, or null. + true if both EventPattern<TSender, TEventArgs> objects don't represent the same event; otherwise, false. + + + + Gets the sender object that raised the event. + + + + + Gets the event data that was generated by the event. + + + + + Creates a new data representation instance of a .NET event invocation with the given sender and event data. + + The sender object that raised the event. + The event data that was generated by the event. + + + + Base class for historical schedulers, which are virtual time schedulers that use DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Base class for virtual time schedulers. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Relative time after which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Absolute time at which to execute the action. + Action to be executed. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Starts the virtual time scheduler. + + + + + Stops the virtual time scheduler. + + + + + Advances the scheduler's clock to the specified time, running all work till that point. + + Absolute time to advance the scheduler's clock to. + is in the past. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan. + + Relative time to advance the scheduler's clock by. + is negative. + The scheduler is already running. VirtualTimeScheduler doesn't support running nested work dispatch loops. To simulate time slippage while running work on the scheduler, use . + + + + Advances the scheduler's clock by the specified relative time. + + Relative time to advance the scheduler's clock by. + is negative. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Discovers scheduler services by interface type. The base class implementation supports + only the IStopwatchProvider service. To influence service discovery - such as adding + support for other scheduler services - derived types can override this method. + + Scheduler service interface type to discover. + Object implementing the requested service, if available; null otherwise. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Gets whether the scheduler is enabled to run work. + + + + + Gets the comparer used to compare absolute time values. + + + + + Gets the scheduler's absolute time clock value. + + + + + Gets the scheduler's notion of current time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial clock value. + + + + Creates a new historical scheduler with the specified initial clock value and absolute time comparer. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + + + + Adds a relative time value to an absolute time value. + + Absolute time value. + Relative time value to add. + The resulting absolute time sum value. + + + + Converts the absolute time value to a DateTimeOffset value. + + Absolute time value to convert. + The corresponding DateTimeOffset value. + + + + Converts the TimeSpan value to a relative time value. + + TimeSpan value to convert. + The corresponding relative time value. + + + + Provides a virtual time scheduler that uses DateTimeOffset for absolute time and TimeSpan for relative time. + + + + + Creates a new historical scheduler with the minimum value of DateTimeOffset as the initial clock value. + + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + + + + Creates a new historical scheduler with the specified initial clock value. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Base class for virtual time schedulers using a priority queue for scheduled items. + + Absolute time representation type. + Relative time representation type. + + + + Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value. + + + + + Creates a new virtual time scheduler. + + Initial value for the clock. + Comparer to determine causality of events based on absolute time. + is null. + + + + Gets the next scheduled item to be executed. + + The next scheduled item. + + + + Schedules an action to be executed at dueTime. + + The type of the state passed to the scheduled action. + State passed to the action to be executed. + Action to be executed. + Absolute time at which to execute the action. + The disposable object used to cancel the scheduled action (best effort). + is null. + + + + Represents an observable wrapper that can be connected and disconnected from its underlying observable sequence. + + The type of the elements in the source sequence. + The type of the elements in the resulting sequence, after transformation through the subject. + + + + Creates an observable that can be connected and disconnected from its source. + + Underlying observable source sequence that can be connected and disconnected from the wrapper. + Subject exposed by the connectable observable, receiving data from the underlying source sequence upon connection. + + + + Connects the observable wrapper to its source. All subscribed observers will receive values from the underlying observable sequence as long as the connection is established. + + Disposable object used to disconnect the observable wrapper from its source, causing subscribed observer to stop receiving values from the underlying observable sequence. + + + + Subscribes an observer to the observable sequence. No values from the underlying observable source will be received unless a connection was established through the Connect method. + + Observer that will receive values from the underlying observable source when the current ConnectableObservable instance is connected through a call to Connect. + Disposable used to unsubscribe from the observable sequence. + + + + Provides a set of static methods for creating subjects. + + + + + Creates a subject from the specified observer and observable. + + The type of the elements received by the observer. + The type of the elements produced by the observable sequence. + The observer used to send messages to the subject. + The observable used to subscribe to messages sent from the subject. + Subject implemented using the given observer and observable. + or is null. + + + + Synchronizes the messages sent to the subject. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Subject whose messages are synchronized. + is null. + + + + Synchronizes the messages sent to the subject and notifies observers on the specified scheduler. + + The type of the elements received by the subject. + The type of the elements produced by the subject. + The subject to synchronize. + Scheduler to notify observers on. + Subject whose messages are synchronized and whose observers are notified on the given scheduler. + or is null. + + + + Represents the result of an asynchronous operation. + The last value before the OnCompleted notification, or the error received through OnError, is sent to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject that can only receive one value and that value is cached for all future observations. + + + + + Notifies all subscribed observers about the end of the sequence, also causing the last received value to be sent out (if any). + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Sends a value to the subject. The last value received before successful termination will be sent to all subscribed and future observers. + + The value to store in the subject. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Gets an awaitable object for the current AsyncSubject. + + Object that can be awaited. + + + + Specifies a callback action that will be invoked when the subject completes. + + Callback action that will be invoked when the subject completes. + is null. + + + + Gets the last element of the subject, potentially blocking until the subject completes successfully or exceptionally. + + The last element of the subject. Throws an InvalidOperationException if no element was received. + The source sequence is empty. + + + + Indicates whether the subject has observers subscribed to it. + + + + + Gets whether the AsyncSubject has completed. + + + + + Represents a value that changes over time. + Observers can subscribe to the subject to receive the last (or initial) value and all subsequent notifications. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class which creates a subject that caches its last value and starts with the specified value. + + Initial value sent to observers when no other value has been received by the subject yet. + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Unsubscribe all observers and release resources. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed observers. + + The type of the elements processed by the subject. + + + + Creates a subject. + + + + + Notifies all subscribed observers about the end of the sequence. + + + + + Notifies all subscribed observers about the specified exception. + + The exception to send to all currently subscribed observers. + is null. + + + + Notifies all subscribed observers about the arrival of the specified element in the sequence. + + The value to send to all currently subscribed observers. + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribes all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + Abstract base class for join patterns. + + + + + Represents a join pattern over one observable sequence. + + The type of the elements in the first source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over two observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + + + + Creates a pattern that matches when all three observable sequences have an available element. + + The type of the elements in the third observable sequence. + Observable sequence to match with the two previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over three observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + + + + Creates a pattern that matches when all four observable sequences have an available element. + + The type of the elements in the fourth observable sequence. + Observable sequence to match with the three previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over four observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + + + + Creates a pattern that matches when all five observable sequences have an available element. + + The type of the elements in the fifth observable sequence. + Observable sequence to match with the four previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over five observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + + + + Creates a pattern that matches when all six observable sequences have an available element. + + The type of the elements in the sixth observable sequence. + Observable sequence to match with the five previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over six observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + + + + Creates a pattern that matches when all seven observable sequences have an available element. + + The type of the elements in the seventh observable sequence. + Observable sequence to match with the six previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over seven observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + + + + Creates a pattern that matches when all eight observable sequences have an available element. + + The type of the elements in the eighth observable sequence. + Observable sequence to match with the seven previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over eight observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + + + + Creates a pattern that matches when all nine observable sequences have an available element. + + The type of the elements in the ninth observable sequence. + Observable sequence to match with the eight previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over nine observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + + + + Creates a pattern that matches when all ten observable sequences have an available element. + + The type of the elements in the tenth observable sequence. + Observable sequence to match with the nine previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over ten observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + + + + Creates a pattern that matches when all eleven observable sequences have an available element. + + The type of the elements in the eleventh observable sequence. + Observable sequence to match with the ten previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over eleven observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + + + + Creates a pattern that matches when all twelve observable sequences have an available element. + + The type of the elements in the twelfth observable sequence. + Observable sequence to match with the eleven previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over twelve observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + + + + Creates a pattern that matches when all thirteen observable sequences have an available element. + + The type of the elements in the thirteenth observable sequence. + Observable sequence to match with the twelve previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over thirteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + + + + Creates a pattern that matches when all fourteen observable sequences have an available element. + + The type of the elements in the fourteenth observable sequence. + Observable sequence to match with the thirteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over fourteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + + + + Creates a pattern that matches when all fifteen observable sequences have an available element. + + The type of the elements in the fifteenth observable sequence. + Observable sequence to match with the fourteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over fifteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + + + + Creates a pattern that matches when all sixteen observable sequences have an available element. + + The type of the elements in the sixteenth observable sequence. + Observable sequence to match with the fifteen previous sequences. + Pattern object that matches when all observable sequences have an available element. + is null. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents a join pattern over sixteen observable sequences. + + The type of the elements in the first source sequence. + The type of the elements in the second source sequence. + The type of the elements in the third source sequence. + The type of the elements in the fourth source sequence. + The type of the elements in the fifth source sequence. + The type of the elements in the sixth source sequence. + The type of the elements in the seventh source sequence. + The type of the elements in the eighth source sequence. + The type of the elements in the ninth source sequence. + The type of the elements in the tenth source sequence. + The type of the elements in the eleventh source sequence. + The type of the elements in the twelfth source sequence. + The type of the elements in the thirteenth source sequence. + The type of the elements in the fourteenth source sequence. + The type of the elements in the fifteenth source sequence. + The type of the elements in the sixteenth source sequence. + + + + Matches when all observable sequences have an available element and projects the elements by invoking the selector function. + + The type of the elements in the result sequence, returned by the selector function. + Selector that will be invoked for elements in the source sequences. + Plan that produces the projected results, to be fed (with other plans) to the When operator. + is null. + + + + Represents an execution plan for join patterns. + + The type of the results produced by the plan. + + + + Represents an object that is both an observable sequence as well as an observer. + Each notification is broadcasted to all subscribed and future observers, subject to buffer trimming policies. + + The type of the elements processed by the subject. + + + + Initializes a new instance of the class with the specified buffer size, window and scheduler. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is less than zero. -or- is less than TimeSpan.Zero. + is null. + + + + Initializes a new instance of the class with the specified buffer size and window. + + Maximum element count of the replay buffer. + Maximum time length of the replay buffer. + is less than zero. -or- is less than TimeSpan.Zero. + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the class with the specified scheduler. + + Scheduler the observers are invoked on. + is null. + + + + Initializes a new instance of the class with the specified buffer size and scheduler. + + Maximum element count of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than zero. + + + + Initializes a new instance of the class with the specified buffer size. + + Maximum element count of the replay buffer. + is less than zero. + + + + Initializes a new instance of the class with the specified window and scheduler. + + Maximum time length of the replay buffer. + Scheduler the observers are invoked on. + is null. + is less than TimeSpan.Zero. + + + + Initializes a new instance of the class with the specified window. + + Maximum time length of the replay buffer. + is less than TimeSpan.Zero. + + + + Notifies all subscribed and future observers about the arrival of the specified element in the sequence. + + The value to send to all observers. + + + + Notifies all subscribed and future observers about the specified exception. + + The exception to send to all observers. + is null. + + + + Notifies all subscribed and future observers about the end of the sequence. + + + + + Subscribes an observer to the subject. + + Observer to subscribe to the subject. + Disposable object that can be used to unsubscribe the observer from the subject. + is null. + + + + Releases all resources used by the current instance of the class and unsubscribe all observers. + + + + + Indicates whether the subject has observers subscribed to it. + + + + + The System.Reactive.Threading.Tasks namespace contains helpers for the conversion between tasks and observable sequences. + + + + + Provides a set of static methods for converting tasks to observable sequences. + + + + + Returns an observable sequence that signals when the task completes. + + Task to convert to an observable sequence. + An observable sequence that produces a unit value when the task completes, or propagates the exception produced by the task. + is null. + If the specified task object supports cancellation, consider using instead. + + + + Returns an observable sequence that propagates the result of the task. + + The type of the result produced by the task. + Task to convert to an observable sequence. + An observable sequence that produces the task's result, or propagates the exception produced by the task. + is null. + If the specified task object supports cancellation, consider using instead. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + The state to use as the underlying task's AsyncState. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Returns a task that will receive the last value or the exception produced by the observable sequence. + + The type of the elements in the source sequence. + Observable sequence to convert to a task. + Cancellation token that can be used to cancel the task, causing unsubscription from the observable sequence. + The state to use as the underlying task's AsyncState. + A task that will receive the last element or the exception produced by the observable sequence. + is null. + + + + Represents a value associated with time interval information. + The time interval can represent the time it took to produce the value, the interval relative to a previous value, the value's delivery time relative to a base, etc. + + The type of the value being annotated with time interval information. + + + + Constructs a time interval value. + + The value to be annotated with a time interval. + Time interval associated with the value. + + + + Determines whether the current TimeInterval<T> value has the same Value and Interval as a specified TimeInterval<T> value. + + An object to compare to the current TimeInterval<T> value. + true if both TimeInterval<T> values have the same Value and Interval; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has the same Value and Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the two specified TimeInterval<T> values don't have the same Value and Interval. + + The first TimeInterval<T> value to compare. + The second TimeInterval<T> value to compare. + true if the first TimeInterval<T> value has a different Value or Interval as the second TimeInterval<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current TimeInterval<T>. + + The System.Object to compare with the current TimeInterval<T>. + true if the specified System.Object is equal to the current TimeInterval<T>; otherwise, false. + + + + Returns the hash code for the current TimeInterval<T> value. + + A hash code for the current TimeInterval<T> value. + + + + Returns a string representation of the current TimeInterval<T> value. + + String representation of the current TimeInterval<T> value. + + + + Gets the value. + + + + + Gets the interval. + + + + + Represents value with a timestamp on it. + The timestamp typically represents the time the value was received, using an IScheduler's clock to obtain the current time. + + The type of the value being timestamped. + + + + Constructs a timestamped value. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + + + + Determines whether the current Timestamped<T> value has the same Value and Timestamp as a specified Timestamped<T> value. + + An object to compare to the current Timestamped<T> value. + true if both Timestamped<T> values have the same Value and Timestamp; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has the same Value and Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the two specified Timestamped<T> values don't have the same Value and Timestamp. + + The first Timestamped<T> value to compare. + The second Timestamped<T> value to compare. + true if the first Timestamped<T> value has a different Value or Timestamp as the second Timestamped<T> value; otherwise, false. + + + + Determines whether the specified System.Object is equal to the current Timestamped<T>. + + The System.Object to compare with the current Timestamped<T>. + true if the specified System.Object is equal to the current Timestamped<T>; otherwise, false. + + + + Returns the hash code for the current Timestamped<T> value. + + A hash code for the current Timestamped<T> value. + + + + Returns a string representation of the current Timestamped<T> value. + + String representation of the current Timestamped<T> value. + + + + Gets the value. + + + + + Gets the timestamp. + + + + + A helper class with a factory method for creating Timestamped<T> instances. + + + + + Creates an instance of a Timestamped<T>. This is syntactic sugar that uses type inference + to avoid specifying a type in a constructor call, which is very useful when using anonymous types. + + The value to be annotated with a timestamp. + Timestamp associated with the value. + Creates a new timestamped value. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to Could not find event '{0}' on object of type '{1}'.. + + + + + Looks up a localized string similar to Could not find event '{0}' on type '{1}'.. + + + + + Looks up a localized string similar to Add method should take 1 parameter.. + + + + + Looks up a localized string similar to The second parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Event is missing the add method.. + + + + + Looks up a localized string similar to Event is missing the remove method.. + + + + + Looks up a localized string similar to The event delegate must have a void return type.. + + + + + Looks up a localized string similar to The event delegate must have exactly two parameters.. + + + + + Looks up a localized string similar to Remove method should take 1 parameter.. + + + + + Looks up a localized string similar to The first parameter of the event delegate must be assignable to '{0}'.. + + + + + Looks up a localized string similar to Remove method of a WinRT event should take an EventRegistrationToken.. + + + + + Looks up a localized string similar to Sequence contains more than one element.. + + + + + Looks up a localized string similar to Sequence contains more than one matching element.. + + + + + Looks up a localized string similar to Sequence contains no elements.. + + + + + Looks up a localized string similar to Sequence contains no matching element.. + + + + + Looks up a localized string similar to {0} cannot be called when the scheduler is already running. Try using Sleep instead.. + + + + diff --git a/packages/Rx-Linq.2.1.30214.0/lib/WP8/System.Reactive.Linq.dll b/packages/Rx-Linq.2.1.30214.0/lib/WP8/System.Reactive.Linq.dll new file mode 100644 index 0000000000000000000000000000000000000000..6d89076a1aca277e8d01c8bcc75c20b5e972158d GIT binary patch literal 692296 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        $BG*nD}9CNLOz@Q+cXb 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

          &-NffP3B*FwlhfDydM5ZIk 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 z zvh~W69_6=pJwAVnCI8Uc!l~Q&_m8N3%UsZforBAIKR;(JVyZC}d^);0q9c>Kz TS3I?glsOi7_~3;bEY|-6={PW4 literal 0 HcmV?d00001 diff --git a/packages/Rx-Main.2.1.30214.0/Rx-Main.2.1.30214.0.nupkg b/packages/Rx-Main.2.1.30214.0/Rx-Main.2.1.30214.0.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..cb36ac8a24550e542b24762bbad29385a24ab8a2 GIT binary patch literal 2753 zcmb`J3s4kw9LHBc@XlC>Rhjl^O2s{_j}0+ue5mcL&8} zKG2zjQpdDWECoczGE>kDHEYVS%ygv5cV?3Vq@re#ljGEX7q|z3V~uySJF~mL-|zqX z|M$C}?>~E1WYi!`{at=-_7tp4DZJ7T!_;Firo#$k;8rM7J>%7*vG|R{wa}iYYx@pb zQ%gK<+y`WZ7X=$(AZY>z0xNR7;Ia{3=+q|>sdj5Fa5E4^D22SF;3!2|r3flwFj>u*HlEP)3>_PoZvtHHh$hw13zaj_6g`3RFaqxc3MBA6Ms@*cBdFXGeHOzDq~KK~z!G={XCrc1huH$gnT=#M)K=$!0Q2NZFIHLmqW0He5 zS%BH%1j(F}V`sG#zQXJyU(O+PyD)N-=2l~lpPiC#+9y%yZPJI z$At3zLoE?t_j_^chg_Nd)&6ty6UxqvYpa-WdBx1;UF`M~mV{ka*XfwLiDFLO#DciA z=+EXpP(5t2F25mvPU(U5FAdt9T=VznO5-=g(dPOO4j*f-sDE;F@uEQwt~nXcWzSu* zeBPwYQ+jOWF{kDp)D(Q#atH2kmC^*8ErmYIFm@(v8# zVk=KQxX`)QS{kprGNQ4)b?oY`TQ)r1yz~$Ht?CZ*5$RWWA^(7VXVLYIvE-hukuU4$ zKVx@oP56FQL({3G#+W%rhczZFzwI0I@JTPs88-je=WQR|8i!XlU48%c3pLYItJA5K zzkg~g>hG%YFK+TjA33PXCCC?c$G2slL|~YDB?=!X>-YOfzey{MKxd$y%gTIK zW1^lH6vzlH=&B#cxL0KM$rQVlV^dfeFi@23S>2e#r;4&9${J;@R7ivx%>jj#c}bb|C1zik2U^Wi1A!eo^KWR37hbqR%+gRvCvIXw$&ceX0(uR3J|s z0rJoddR-@d*h*<*cLrNE@(1;&AvgF9ooiUvUXGBf9*>}JXzo-IEvo + + + Rx-Main + 2.1.30214.0 + Reactive Extensions - Main Library + Microsoft Corporation + Microsoft Corporation + http://go.microsoft.com/fwlink/?LinkID=261272 + http://go.microsoft.com/fwlink/?LinkID=261273 + http://go.microsoft.com/fwlink/?LinkId=261274 + true + Reactive Extensions Main Library combining the interfaces, core, LINQ, and platform services libraries. + Microsoft Corporation © 2012 + en-us + Rx Reactive Extensions Observable LINQ Events + + + + + + + + \ No newline at end of file diff --git a/packages/Rx-PlatformServices.2.1.30214.0/Rx-PlatformServices.2.1.30214.0.nupkg b/packages/Rx-PlatformServices.2.1.30214.0/Rx-PlatformServices.2.1.30214.0.nupkg new file mode 100644 index 0000000000000000000000000000000000000000..b46232fe974d4fa77abefd8a4cb2935fc623b607 GIT binary patch literal 152043 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
            a53I{tOOgG&xqBZSJ+Qbold7 z5spkQiAaMmkj{Z@_2;cDi@lwpG&Fb8^(d& z)?G`f?SjRBRO0zXJ0}WOt1jvY!`{dP@3$)lbsB<_sBc)<9)d*-9?r}2lo;_d+3k17 z1IWEwMY0Z&n|np_6iBVB5s=CSd(e7)pix0VmE5Byc@fN+K+9h*n4$%emelRw92+lY zSEoou5;2_3=*>qfLQ0>=oNqa{UT~uzEDmr3(qgDO`iagVa*4A`_!RXQ^y61K?*4

            $01?*Lw=ew1>r!nP-|BddoOaf$7;wk>OBmoy<0!*N;=u z+NJ`1&h_UTqnip}K`CRFzkdoiZ~gKt?AE-^SQZJG?0DZ@o#TK}Shk4#8Y;~ch| zx+1!w_5w;NtlDB^CU$NATm;#qk*WQRnJ(KGpl70hgrU z*i`V5Q=F#oTLBbA6>-vA0Y*Hpzo1pLBtdW5Y4N{Wqk>R%be3qH)$QX$nO=3238s`e z>u$O*Xb!wg!LpEAPObccIfc4v(dfs7+Uoi(ON$gD$6kHmz?_S6Zmu|Soh89EHTh#r z@dA>7#!Ht;NFlpQd%VdjUxjMerLj;`(k%(fZgQ0>(n~Fkz{!2yE z77b@;_RvrzWN-ulr-iy|V-ogNBi5hFIvRxGyiF*bwtzXY{ zT$h~?F~covmWPYq&UtOg5Hf+btK!WlG8AqGHWd*+5trwv!PdR3UI6!VW2~8C?HCL5 z{go8bcxSt7YYNap%Wew;%sa-^ON#Y%H}&41Q3JgLix9IUOYA?6yL8}MKR``i;NfEZ z3kFS)?)(`~c8G?17r9RPcz`>noFcY*y$b>O)zF`vK=iYNH2N~eQsW!*N%l)a_DCA} zy=rKFM3Qq`5T9a_9BTwnQ}A*W)z|a>ICD5dfwgLcaUrq@ZtAL>hp+{*N*Zargr&F= z1#-;9rTCKmgl92j@+&FhiwluklO!3EPpQ(GiZWq@FAT>um3G45Gr}U}Ac$dBl_0SwFgz<(ZGDMk67Z1M`0&&|B9lj80daIXWD$~l zkqA_kzk}NF9nnTTlV3-O-p-Jr5aK$!rS*>Fix?fztT78X-1&&{p^hZ(# zVMdwv--?zu$o~8qz@1?Z5%7=<;v&BH5SD#xMDqE$5xAsNfcY*djC}Fb$muS!j(N2x z1bs&HIhiB2pc&$1#}X4WmetZC!S(nZ@(4QTEI#|VNb8vWHmmy-(gMr3m zA!1LUhS>g$2*7kdJ3%M0 za290a<(-b;mvO7*K8NG}YUY+~1JA{}JWBCVA%vAS-!}z>W97pK27kL1_HVHZ(GW z63r|6oXQrmiqmwko3`ks3DZhf@`$!K3TtF^2O~ zhKNH((qoMJI^m&@fHXB_1nVh8$zOz7Q7W6NBsRt3E@J?_sra`D_x+m~eTeKH03&@M zt*`W!CrWnj0W*C-87X}L6(N0qikdOhv?$w50f-UjZP7#*^vF@rAdaK-I%NLS8z;d4 z3L_3cU-4Ih&-iG+2a-6Rur~;atu2gwyaT5BKR`l#5td3lMc9Qd=nq_#)GV}%%L3ho%netYk#wR^~O+`q=~5{w&sxb0N)N#obQ+_>^e)i z<#7!|Vl<5rkQSBB5?*jgLLxrnPr9Z&vrhvHe3d`LSO zu%AwKo&+{`$O12b9D0fdirY@xXxm=feg>r9Ao&un`kEillwAj~1trLQd9c9Y=Hr<_ z_U!1LOZ(x$Bc5(8IMXPS-_v*q)}-H{CCIOeB(;0J1y%(^pjCPzt1zeYV^|gQ1=`)c zouGanayuvs&rY4iBw-w(&nyWG)L0gKFn+;3iUB3TJmNX5GkP;iSOZIUC9H*2|3B`2c0O6^7=$f!yoyO6hC^+bLN_?y?UY9_l9 zVCi;UHM6zMQ#>QE?B(H>S2Z(yu2(ekFQV7W#jbb|NdnAMFJ&19N;q32IKtOqW6nGj z={RNo%tV+HlE~A}po0}_^?2GxNNthYCrqc)cuJwWM}chsD5{NL_S) z4^SrUNvOZ-6WMFhv({*nA)N#l-p9BnwLVrfdo^%RDM&hb!K!9$(jG7|SIE)J)1|_s zJM!S3LK*sy0HNnh)Gpn-14K$4K&Tt@9?Ls?sRm%2>sAI7Nrys+PqGaGdsp03QTWi_T$fld|-MBC?DbiI;LjJAa&^C&cG8U^npUFcsq|nJIRW+q$ zcS4m~7%QWbd+mSNDXELpu_KqtM5$G{n-RcMgra4z^5en2nc&DU^!-5mR`PPF3yG0B zBcw_EwZfWE79A#GfzblNjoC~enMSKltxid!Vf={PtXyu8p-)UTv#i2>HlpKfLn$oF zn#e~;Fp*TDG8kQ2Rgt&n^;U&e@_|HY^RSTBq;qEj-wIGj(cMJM_CE4-UW66j_|j|<0p z4VkakLTMt&7U@w^HE@z67N#`qNuVfyX64fv9}Uo{ZSu0UPQ001?nUS^@B3oZ&?lM) zQcVaaqNRE(D3Nx&klLr0_>V=im;Pv!%Yj71aBC=YHml<&s8*IcmipA=ky%kS*wl(8 z6Mf4g9IxV!qQhd!LN4=qqazGi08 zr)I)83b@Pliz<`#bP$_z0Ui2D+K{t1XE_^=gjzUK=;(1v>kz(`)C!k8B z+!J^q1ni}_ijzb?5O}}s+(6ym9~6WUs+5ZZXRh=Z-&DQ)Z7L4onM_1GNPZTot-bG9 zV&cpkfI`<86bvBkjD=3ul#|hkSq7)n(U4v&1rh`FYlWQOew|fTl13bhpl7{9zn7MU zMK!`gP98QT@p~1rN)%0`S%yiwP5A;m7tUk^$5y>;sGe(G|Vvf9U4P{z`bFdBwu&!ujuJ~{UCA_k^7IO z-6=Vm3y0oyP61_vHG%EDf$`_rFwAoXn&voFO=bi+N}VD#N{eW70*pP#P!kv~^Gkn3 zo3w~KN+>=w6A#>yqb`xVF8qS^zL+Jom>JCUkmIP-39JUPgwJ2}=BN{5 zm|(D#Xm0_%q5HtQFP;r(*Yr&`%z-;abpil*Bxz*D!D-GEOGnO&g51w_gRtc@@ zd!*1RB!L6tE2$RDd}xdk+DI%KPENSw1~`)QQ5HLChh42-cEos=YX;tbhtaz%p@`^2f8X36>Zs%J3u@Sm^rsFN)r&)?G2fp4B7e?-BE zY5~H=b@x=NFg5;bb=uO64tH6K&}=JFI|1Z-;3i8~yO)PapTIVc5Rp7=)t8|7q}X=i ztg-ZoF^qi?Dy=1y^4$c&sv@HY4Jj>@&x_M^=J4b>MJVVH8}*VEp-j9Lpp|Y1R#vyI zcv%v|9`UZ^#`ezQvq@Lr6&=UCR_=4a>9$JOUytV1pa$}2q@lB)b{cPFkqGu^8_{Do zCsuc}^JgL18i(*IAEaT%)4B%+2||SQe2*2K2}EgW2%W~7NJy0EKIJH(-R<|f>EHU0 zKD09Qn@M6T8e+nZs zeb{)=27N-Ox#NAvGk&#+*XVR`WU!gBUg77WOR#5VbsjUAcmapcR>v2S27sF@`AT z5LHHzvdHt5)*laAR*QJn?Gi;01qBc~Xer@;l==IcS&h!Nlz)_*RiK#n3(>>p?0pqU zvZt6;fXEOO=7)^E3Ses1M8*Y(!w%@MdOKmwF=9$2!852;P~q_8c*E3^S|x%~D0OWH zT$xW6?GQQ`Jf4fZrg()>?I6i!#kz`b`X#5eMm){y?@&=x{(6ZuW;fJ~ceGxK;RLV( z4sNIIb}u9zYDv(~eug5OpO+(hftXukA(+Pu@+^ff`eu=drSv2e+0ekCPD5sJT2jYl z7Ba9tHM2+WXAG~AvWcoP=&@~Jt&`TFWUlW%ui#6Hfy;w4idaC6Ac!A?rCAUZW@=N_ zF%t9mstReS0nFk$K1TElf_Yf6T&MvY(t5_k5QJ$KTQs(|szUlCb1dlD@32n4hVKIj zl+YG1;2%%}%lv%>LA`#i$`v7taj^fSZA5ArG2@PqqJad;e|E%0Eb$I-A**ss4leLz zt;p2laHkQqy9__o{cwS-0O?`TYVXM8VQ0g3q0w77ML1YP{fUZ;ea?(w9&LAfD7C8# zX7~YJXhFeEb3lRu`iJ{C)69epiejVEja(WoPVGDHpn37un7M zwc%s;VjTQX6{$Nmri+h);z8q+XK&Tuh`TF8oN<%E+3UA%`l=u7RAgp$CVF}|LNvz( zMDQZV{1M5<*hW@0cxxwa@pRC}rRn>zI-X=@ryYaGoS z-#%G^vB(8+7W*i@@PSB4wWJ;24`N2ERUP{eEq-P?Qv$|3S`PgUoq{}BTQ<=Q9DM@! zbEk4<;)3c%r3^TLoWW02U3NC|${+E42`#PS-mM|G-Rl`RxaUsHbb8Pzn&D-&ZlO{P znJ5vs!Kd_NW&A5yp<^TXJZGny4MDc$S@=?wwr;h?9X7OJ1aX}kS#%(ES|^=)J=$-! z-B5f3Kc{$w3mN#Bu|}#PprlZ{8NO`E*tptYexPFwV)ZEp7NXKC3nE^`#D`1i9`G>J zealhu;AXSefr?l-^LHyDKHWX4-`0$0wX#>w6P zG(>t@?bI*=bQoMn#~|NXYa0evLNiiT2;TcK`RLTL>DrGj@nv>6D8c%rsx6k1-kO?Ju zPELy{l0%zfMWh)bBaa`JAQ<|3hnD(dhOdGr^wOjR2M(yRtx9p3z?2A!PJy$|>Q%=t zORL-oS8RqeS1K4f6+p@?B8*|vY8!dWBn=b#FP0H;87;vOp@vzIV!hjmQI4QW1iA$U z220jNN>&C0{M=d8KfE6HjOyO{jT#hb5>P&hwMw<1F%IV}7*f?*Zo~a0%v}GbiavdV zu{YidWwuHGDzRrzOW$vlcU8EP^#|Focf-OfoV9weLs6m{!-Qi3Ls`c6B<0m)R!!N) z*F?@HJg-2nlADX-S8EqW#!bqPMzu1Dl8%9ERx2}Zmv)QrB z&U=^X8}83T)znWmJDUnU)U@nq^+Cb(B&jhn@sGC+1gp%Cn$_>`j~!p?qN#VGk0tbr zgv|WiJLqq7G0O_)<@Zl|O+tTVj!3a@>GLrmI0dN2S2%w97jf{%u`uKZ!rUP)04{y^r42FoCPu}eW1xI1`5XwWc-QZKvMHUs!;Alb`3pd zFhz-Ieo};F#mtQ)nb=|FsA~f`4$#rQHdvEZ9Sb#+b@UI>c`2B?Ocsy>Or(4um+1C3 zlafgL)z7pBc*Tjo zwp$^zcv2){$uJP+{ge#3?Gi^w5jR4=K5S=jQD!^E7IzK(+wfkyIMhp*&1c1n-Du!Q zYXjL`1e!125t76ghgO8@evG06hWqj2#uO6JA5yOr-I??=Nhi9`J@Q0a+;vWPOQmY% zmqdEgcLd`GDf~wsGmbf>7I#^(eL#StJn5n0@ux2D&g@tHaS!4dp4<%-}&U)MSWqX+^==$xx;U*r{@!SzL7uqUrcJamI*LZ!4^*9%;p1mVTLo~xF69ikx zVozcb*u;p%$VskpK8lDb994wVEcm413A;*qS&H;XxgTUPODwCA>1M~{=9#3rBezOxkKv|MaQ7v0kICp9aiyR9@0UZsTeHKxw?S138 z+_+wKWi4{_qEJOnTI@a-xB48g|CVq(Y{6AKx@v7!UdCbV(vh0*b8nG<(Lw{--PIiv zk*M>}qWkI5*RQI>_Tb}oDQ=7py-s0XKBlwA%bD|ImWkv{NL##obY%Rf%REaD!Z`+; zsf~+rzZrs_u_@`-B`VAJpXpET+Er|hQQs)YnY@kl4|g@;h;90RQtp<7I2&U8KbpRy z4n{8M-haQp?p}4YWsgF{@E5T4zaOm(@a40HC;&bTps3zAC@tEw`EJ|OCJl=c+YyA+ z>Ny>n9OjdbPR{MkY^;0=$HQ|NN4V0aGjlaqexciQll|_`noe$yx#(>0befO(Q#`LY zwelvhU{t)+Ei-|_UNo8!%xItGjQ9i85E~(LbaBt=2VM;OzK%0Pom=<9X{bG)K|1Htz9Z@Z)&(?80o5jBAe|s&OLwp2R_Y+_hIvm619MlO8;%&W#7IEjv*IQVm1|- z$)7^hMRhVVac9#^tFl}ui_`vJHdw!XUcPYPBlis#H2m79xYty2PI~>?Og$b1!58qb zW-r@b9?&NRqNAo2S7e=*xPFod_lykInQ{I&UF^LYIf(y@P%XG&JRUo(NG9L2)WvR= zF+OfJS%te;pH4|M%WrVEZaaUy59{%sH;t#_G^68tA!T>$Z9ex`1^R~TPB^iUFNXFW z-Cd#VxNWC*Dk23;mO9&_0a_xAFT*X;ad0 z1ZV23p!lWb&2v2~60yRg67wb95SOzoV3iPDb=Cd?&zZ|*IDLlk;2jx=Hs5hjLe{ld zy?UkS=c|;Z!t5|!L0)KEy#||ac{@sv_r=&{cp*_a?idTC< z4t3H3o3p65!UH?>`074n3)lN1{rj8jVms~!F8$-X+tVv-i*AriPI~=OqF79Rd3kw! z{05oVYLMJ;);DbYVIRAxu&#CmyO3@XN*F~5{2;oCZs==Rc&8Uj|F#2z`1W>@MT`I+ z=|z5=l%MupI^m_&$aOnlRouY$hKt46dL|>3qQ|{nVFHZauhyMbzdZKMbFg=F8aPj; z@hxa_7480)OCf@9{o^SiB-IbjPy%-qFzzz#o8#WQHHJs#eJP#PW_L7oWf0HX;5Yuh z2py2m<={MgMcn>`eSJwILE%3tbTiv+?x?}PSujRoGxb<1QMLJ@kXwYrUwfTR#CYA_ z**EcgJhK~HuHYpYsBx9hCw|YwqxDFg;ckEXg{&V*ZyU@S)PCY^Mu8zInh2B{Vd<*;ATW`Xv4DwIGB`6 zRvk1fLn8-TAIQigs(%%UvrH7j)gS5qo?kje7z3NL&|tAblJV+!=IS>@CXM;!WCT`G`-Qj ztVRp)Rh@tb2Y=>A(x0YPmM%~Yf(`!Vg74bt*aQAX^l0w_Jk0)5z47quH9IeQM^%J6 z7StX<^}XJt+P1Km`4}GgkG)mHoP8DFF1x3%=zzm?{hKnmwXe<0Jm)K0q_#Zv)9V@c zB<*S5QF|=PI6CWPDXLPewYsBsE z^cvD3{h?KMJpOlao-|>1PiS7=Q6Js>{jy$F!iorA$s}8bz^vscMjFJ7sVmOK#gKsn zYjIfMuh^OKc>J#i<(YIE4N9)Mb`?acj_u-!hw)Y0E)kQfS=u@Ce6#)r(aBKddYh*7 zkrtv>BU|aeK{$!L>4IEcg4Ir^cRMM@pR<~J{=g^k=r?H9f%+OPET=&hADKaMc#Me> zp$qx$hjq)MqH{gvD*KyT&|u$M1?sLlPV?b-od%tA=gMDS>36i{y5fY9nhY6?Hwv*b z-@dO#HX+mw#ldg6oKw!B$&seXpA4qpRs7&1gtgB{$TE@gRj#hbUUiNEJ)$F@st#uX zVbFgJtD?8X)Mf?O?adxSp#A)9Ur6^oWdnBBZGFn=E4X}?j2Bs?zxdM6OI;Lf_2iM~ zq%=o&W381o$AXS=*Wi@Ea^@D5so}mxfH(}ba<<8b%tsDv4~jEf zkg&;}e==u>8fO@yBFzS>MXH0Kp+EgjG<0i07Do&sx!c4TMpx1zjRsoqvu^^18}}g5 zCsaOJ-iv6KhM5`y9wIQ~kL)$P>Mowv#zfn=&#w-a2FmAaw`Rf_7r$Lz3$v~AJ`;PK zRVS}HnGkOyw%I+L7p6Afvbk#fG@BS@?l^CioxVl65YMHNnKEcx{}vFnQ=L_8Ub&aI z9qt&~ai=#EpN)j=T_qdJ!DYUkOrFd-AUj-M^^#b7%LjcDpS-26pgYJfHF`PIJ#USj ziy}{9$3zRvoi6FI3wkSi^}T>Owe_8^qKVamMdyb6qtOf-9JnXEtYXSS`Qy32jF%pbYp%ccr^Wfsm)_OKS%qhN1I ztI#tg(DESt)qQw3ZjLUg&S5io_Wu0ZP5;YAIJ(?{@CoUUY74s$h2c@Y`kSEt6EzcE zWbOQIHRUR+;ds1w4v+qg@i^i2#v+k^Jr|*%PvvegP&C`zV|zz$LCB<8L8pYgR{nA# zfvQn)6(dy-#q;7wJ3ShAhgGKAyZ!xOODfqsQ?++Q8~Cy{(|iH2RcQ!zeFRgbaDfn|8%gg33+Du*ne6IVfj4;6;qhvTNA z$PN|X{ZcG8C*6UVuGt2LrEHWttlD->ZRR=Gz%5WY3Pb3R7eMTH+XSW1S76OI?Dup_ zNCO&wTRb+;i+2=Egkmp>`IqV5jiJ{K&oZ#O&d`Bx8|WD46P&HRs!^Zl8RzA~IHFgegC3fW0@wg)qgzk5z8;wHDRGX1aka7TJe` zfc0Xyn%;I*vGgT;gTIrAuim@dZ=g__XdwO~_q1_;XaeQ>&kH<&$}HET8!fTHg=%Ub#e;Q8*fUn27Dk&6T&av2fj7xn9scH0MO+?JvC z&J7hWi8!me$QeouWvlBy>fRsSM{LfulAj|DcOKkt(9UhUUv3H##lI(fzS)^SMtriZ zd>s3T%S>o5eCbA5F^m1L{j1rIqrVT1wXOesMqkybzZ_&fKQUA9I<-adZQK2|17|M0 zN~s!lqp%m!+VSpm)wG=+pXwS@r~#~o>pa5A`1ZHcJ&N z+9;o{J)EZFRc!CE7DY7Z1ilVOpeyRA&N|rRk?j)vSbo-!4?0>#>W%LO1gO_e=lD-+BBI<{fV;`M7g&uwc6VJgPhKC@M2c zPJNlj63&S&tJ10b1c4<{&ZsTtch%cydBWj9__BkH>sw;F5Ul-%{_n3D@q91UrqA|w zzlGeq+1$Ou>679;t>)XIpulP#FxDfKo zl>X(Bp!1?2TyAG^)H-A7Ahu5A^xH|EbK@CEP}vv@3d9!i&Y zo0fLniO>v*Wo$vuDI}L0vsA#G@3y6K=>bC7f-{`FG6H>j0HeXz8>0P|xTE^8Jbqo} zm1aB{>s${r6zDmzUm|L;zHMZ%u)Jg)Opc0@!QwO50H-JB`}_0R!oG&--Eh+{IdPx{ z5qM(Ic>O(-^4wEJ5ExGy+qjWXBFD+Rb2D6?C7IUp^;Bqm$H7zO?n2jj`h|!Y?PHjEf9Zj3y6uh0Khc)qlWJo-q)OVjgAGG*(wuU51qWXh)Lam4T(q~aVla|=EZ z$Gc(b5wx$o3t5+c|KkO)R?T;Yf&vKA(6IXI8SwJe$bKMm;S3IT4$IBEBh=hS+0;E< z>L#x!r{(>o9PO^TapQAj!g0B{$!DlZ_?_bZvQSYu9&Vrr)V&vcSy>Fuu1gcjTNj(j zTrFH8@o4@_z3us;F7kbd$HGFiO7E!iczX1<6Wpz?>;2{Y6*_&A36=U+F+Ou~dV*>9 z?QaeP9TTtpM&qOB(u_5c-UfT`<59^u;Jn4a5NYQ0Pou8b=mSw36O4k_5*1*%dGc>v ziNW98-s*b&P2A`cgsi!5rLNX>V>&-?k1=r0x%kVL(D1 zPKqy=oQq|qu+JfBwuu*aT|RfyX(FbcKRSX+m`1;!x4Q;5K>=~D%#52GTTbQF%$_FG z~Si)&Xx8`0KcwM|q%b|=3$vw9ySfQ8YuEU+gbL;D#AGEg5IsFQERrx%E zPKsrat%u)o0_m0p5gts26P%CWNHLqmLX^){a8P!nXkquK732?k z97~%rqFY$1`mN8{L1`LJ(!~h%{VuKs#w^?D)9vtem3otxMPkP4%{Z6|UqR=xmT;8y zY@`o9vy_wD)udk*IeR7)rsj5f%e&-lXp+~AaP*qRvNpDp7%6T8)8xyza6pbxy_mkOE2bWKE7i-Dq(AMl;Sk4u_ z;m!JU9halgaz!hL4~!{2y?sfPgKF+gj!&zNYSU#G(E&ZJYqtHvSAN^Zf)Fv2{B777FA3sJ1EN02-!KOo90or+UhK_}UQP zW^U_U#b#7=7X;NPt@s>d*shnuzj@_kHo}xkW561pGWN*OzuZ*ru3(?qacb=Jnwu`UUb;Tje`lZM z`44znrPbeQ<4L?LG~J$~^#y`g{=8RS|M^z2lUi(89DC7RdE?~S-m_MVURv#?PBFe% z#^!3N@2qk?EG!>6s=%Lqt4sv*>Yl=>tfjwVc`EfX75E-dQ~92~U^u+=uh_h*I?k&2 zw5|7%tW)|Z`M!dQyEc7%?Axuyx~fT@scPQ3pCoWdxJwKX1{6_&wOIMwW4+0Eb3uDy zip<9NT6NUtN*RIe57|81G4QKr9OSCi2ncEb-3GSUZyCHMZFTn86gCRm6@tFmk?xv}!AaZy2{bstdNtc5FU+5#?6#Ios#+>1?}{V~~#Htc-YRO1MgX zakq(mKDPc0)eT8)eS%gY?1Vu{LPft|)$-n?PL`$N2ZJwZL{ zUBMW3xBa*uGwtlakI8nzd5QV50oH9JV7*xU-2rP^(>%Fm;>_1G?6Si6Jr3+`LIy22 zdZrgllqT>lC25h~q3^sn8M4MDt(6m3tG?UrF*HO(J@Ii`#mdt*k=Gd98NwBT>pINB z^3eLzVZC|Bq<7JwvwAR1_Q~~ewAYzZC0|~pEo9lgm(iw}e5TM@OFpoA<(L6^W3975 z$C)8t|9AYXd#{=NVS9rZjPu8Jqo_jcAeC^W&Fc@#qnRM_hk0SVk%{ebimWmES7o(ML!SBBJ+#mc_xj?zJj z#s-c0{6ko)T}?)`T!Vbbw)yf`qt-|7E7wJQK)SuT^z+%V-SW4yx645^V%JKi080yH z5rqQHO|51_(_EVL)y;dq|(hYQ8~rtGGTyO+mcW7mv}8i@`r?YWrb zpN7+yxs@EpjE4P%r6ew!t4w*h_s7kJ=a+&^)HDuiO~qs-ZyQ&4yL0mxzmo)$V#}MW z)7O)Q&aG$z&5=g4HNBH5KD~kGQ=uEKhQEsfOlMV>T6MJz6>cw$Vhg|=uCSer_NHAH z4F)<=+HFMn5j8-z+IIJe!(kHV#lN%8jO$ zr^3+Mms27U&k@q=@DIlA^&8lif|4QSspZcB1>X|zOnO`W098c9NCL#%T91*Z$w2UMLE5;LtRO%948I#Plc!=1GUseyP!r^R)$J6g55T8VpAm z;^=9NGL@ubqbmJ!EHP#Z628WrR$M{M>NE+(`JVUuq});|0D(G-e=2mA4Rt`B(bhjL zU#8sYT>BQW!iZqEWOQVWn9}li)*g+AU(Nm{Oh_l8M{bdcIk~`kwrJSV+w`Vb@xgMTB2B+a*tKY;kdW-CAcv zqAGyt^gP~gL06og!Lh_pr`qqUy+rPAY&jakK_0#w=N#6MTUyphQEIC=80ipPH(&I9 zL}BM>CAe~?-50YP-Ge$-v+G-=q$r@CHrZIvS9RV&9yYoxMS}9}by;~mXQgwvNat`% zaW`fyzP`l7Js;JW^lW4|bblpk#6U-2al0+rtBZX->&#Tu%}{r?><^S6#ym~niD}fl z4ssp|$8>vl(b5=b_Ky8#o^YB|NLb3KnV%Xj9ynEN$xjdV2_8CbDskBf+WwL?TfIid z1~7!TLym78ds3%0I9O&I}C8!i3lYn-=vC9s2q0koaJn{db@cqu%jyXm0{~h zT1Y>@w&KGjfB(FHj|+Sl=R&H4R>OZc?pdosU&I76WKg3|FwO8Mq)2fnCaj)G)oA%y zBHr%=fipj7%Srn~zo7-|2hkj(IlN<0>R%s|Z zoYsB(IrojHf*mHXk5MII@nYG+9)O;*EJIBWM9{Px%I+R9eO5H2a^-Wq)+^goDP70j;XIhe5Fh{_plKw8~*G?h~?fS@SD9uACzh){Z0 zR#yEXhd>n^j`k0FN4T|W0`K8Muxc#t24*#psM*^ex2jN0#_aV^c$Xnq&LJq;u`Riyge$`gG4&Pm#={bsu^ z_w#|Pmx0>V9^dA~-K0>;lJ|OALd5|W>~y2Yl(6q)ic|n;eB&o<{WYQcY$;rkxR+l? zBOvi1%(#A$wB;nLUGkHy`+S*EIADM~DJ3?;jX`T?+43+_yt4Cf(=DxuWx3CrU}vD- z>gN9C(k1-~y^b)b9QPL$9=YEy{7!Nx)n*Iu$n&y{@)A`BPm<}ELxlR9_*MX=IH7g_vK~4lk%~!oLs}uPf{GSwOMb~65mHO6o23| zN?O8OB8Rm+V|Afy3@&^#0G|Jty8h*Grb$>sc`dytHl(1S}6mR%p}JWJMK8_oS< zYPI8Bh4fDOK2@(Eo^5NObd+&nMYtD}4#hw6Q2Hrm7B>Npb9!&G+wn|r6^O_;Wv*k?}$e2Zhl!Y;#+hwA|(R0Fwf*di4AqBO!r}d!^~@Ryv^s z{o*mrgl0B(T57<7@8e;()^gVk3a!wg^)!8#p}C*ZRmn)?Ap7_vh4osN{sqY|SDw9W zt+;Ud9@K?avcZ|-edw?^aYBbwI^M&6k$vQ#%8hNmlX*Mw1b+799X!umSQBnV8@~()ZiiYGqJa-^w945DR zI!{NWp67N0Tx5lp6 zFk4EmmwtNjK^9WZemqFH!#gVZo{@%x_PqF$<+>>|tp4pY`Xy8TfqH~#E|dAW6t?qo z`lB6DE*gbV*y4J0PB$TxTV6%UNbGD%amHo!Z+oQk1`z3tP;9eRzhg#8@ht#RNVR^DLo~Gz)fGRGOrx>-$W}MX$ z$6!9|!X{j3f4%?))r#Iqi?7MtvrDDl4;rLZrdzGr=ZQ!HFeJAHB z1xI7O-PFBF09)VLGf)y#=^jn)mUfX=JT1}ct&&x6@eQX3bS5H5F2ljce}kAY6hd!tv?t^PAr z$juAer16u*h8efOvsY%_&x&{+%O~;%fmF_f+E2&FZPzMX#8XGgA5!W~tqz3|Ia{09 zy@;kIJSG1gVls*yuVu3q=a!cCsF372pOQ~?;n%vCOih&u1?!L3!*Y7-t{IQf zu?e@tM8tZc3+<``!~C)1n0PWUd6&j@(R7EL^T+hzK-f@!SD zZ7{>kB)O}dZpuN=_Yo-*O7BZF&;+ed2o*^BwLXXPYvv2TkFgM$nPNgjDcVYf838Z-P?suU*v*> ze)ZY0Mh|z`^&E_Zmjt@s{N!^k9a7A3_?Y1O+2#@SC>5*cDr8wu+dB=R_G{f^|4>{e zX=8uPlJ^+7J#7SkSfN-Bmcb^Oli5)RhK>2hufa zD3kjEjopYf-_Yv zoltN<{Ky)A$f!IkWF*5D%8gX({&4Z=E!}Pg>HVW3I(9!be8;wI<~I2bR<^V~56UNt|xtk1}ZtK@s{0ruDdtwPJEyA;?dDYd1!~@yx)cCMZNl*wX~!ba~O3PtqZU z@Zqv+e}kesS!RpSKD2~gwPQRASsQvASK6DRr6;DE0YWqbj z1}O;S$<#!9@{^-lOo96#etdiz+efvqzKgl=Y{NM&IHfBjLW=-&?7HNANS}a3p#u&Y zDz(?N0ZkXsv^KYH4rq8&cPgn*VYbIVVbMrkIoAYj1elsVaORy_JwnOO&4Ul1)aS>aOH)`F5)i#O`?p3olIQ)~M4$E@^ zKIAY~K8*SVIxU1w0xr3No94|kTN}`_JAxQ!nkiOg{Ku~#cmN(~nn8Qhp)~cuQZBTi ze4^>f>BnuzMU^uYvaP@MCGyF&=zU6Z*TN0zaS{#x^YTdtyVMunNa?Ey7luh*ngL!- z)Yw8?0VRSozMHxb!<@vTGgFk5V7l5?eSD=^f+YTeeBmloi)Bk$Ja6}BCE~xsO(kzdG&CTGQ;ijU1tvkGUZL}WD>?g zh10GAyJiNnP%+omr13=Y!#5JIC&VA^uOSL$kHc2@%tqx~ytWMd$rw_M215%~nusSG z-8(bxcyU@k8ip=5;a@Mks>k2Txn%p|mJW^oE)lF*zNTfpjLpF5YWwNF1(?4D7ftgw zp)ocu2UZxCHacJ!5zC>=!V-FQ+H@pX^1>3EE-#ebU?hdNc`P0tki{=ve;)(e9BDj@LfQe!_Rip-h!8&cNO+gHn^$S>;43bOvsVN5c`b0OW z?>tXxb>Zaoh8>Xdo>b%z3d!^s$Ue|%{O?5azwkc5D8^f;izoKYPPtULfe4CSPws`+KiYB zxqvwy?p5=0hgqPd+A>t(3JN+vDfIdl0&5Tq_EEn_-QQg0u>vmjHqjM5YgpJ_fpKA6 zUFT1GReh9pPyfo$WqYoV3WD@4=zUcGowjiJbd>!lgp$H=%rqUKCP8#BLyb%!c3N~= zp?t_RHv9ykWC;4!`SR&O2JP+JxV6%abR(l9jV;xwii<4OT+QfC{p4oguEaIYPEb>Id1~1bMbTQve8yG{)%v)qh;M~NGzJDuWU8CP~SM1Qhn}9 z3T`?)2E`y*ikYwtxslw*CNaYexX(V&P9GIFyK<~eC1F1UV{+p#s1eY-kmsN?mHyuR z_za_}?DlM#(3bVove)-)H}&pwk7KhL&a1SNk??wk0ui*l<1Fab+H@brYDI$;y2JJ^ zWafi*z@VT&+^*76n6qx%tCZ zVL=e}n0~4laGPms-qUOWpxMD#a^pd18059lC5@=O(yQ0`_joT}0K^{VU_GA!NSihY zL5L2ogX<#|2?tIawFPHG=d;=EQO>}GY0#MPlda)UHNX5R)VW0`ccTgE=9c&`m(6+V zDKMc8tp#5}MOhuiJ|z8+6I9#qIdhc{xnqAK-oUua4==$7bH1yG*W_MBv6E1HvePiJ+>L4 z3a=&#xrCV^PsmXa~ zNr2N`;fCaYUamoNn2O+Fj}d4J{(MDuCYvXazLyoCu0+A~4i0srwDtwqg9QOdcmsm; zZ4$KAAOrL_`GX1V1_z!bFxpw(uu#-t0Zj8#UxRl58WhZKxYo7Zt_24_!blDhC#V(@N^^?{?WoY2JkeLk7!8~^s!6w; zLd=a6J5y~@7h6Z}L{A*C3{gXq*~1GW5nt4^mb#ZNe$GwMjm&5bM_kdw0S#XUX@22uir!a;m-(A$ zJD3U0rAjS@v$gttt7E+xL=^+4;4OPp5%s9h7r}Fqp*S%|)&i z1|I=W@i*d5%9nIZMV1ts3acNV6~u-Tt!!aNZ>+(I@5M9Y0vo)4RQQJ+9B9ql!I#Nu zZx4n?Twe4SKOXOfuEdgOWEhD*`8v!jOa;{I;r>khAfx}q$8hO&FaHm;; z0;)$(HEg8sl_ep{$~siPq34%_?J2wZAtDd0=G4~XI9TC2JOihDM_`R2m0l3S zlkhE0nj;Y$m1VJFE_6;EyAr!j`@Lj#PpD7O8jtiL?$W!zQ6=sz-~A&6LeC}j?AFDC zAiY=1=b9eu#3e8v2@zE%6Mopy0_owhJ}*QB>5mkW8(z>;Pm|f{!hvr<*Og-MD~|5PyCntVDnQPV{PJaqW5+@AvXDUE?j^%Y;t+e%(nUPc z`RV>Ze<_)+s13ZZ=i|VT0-FK|#^jCJ141k&;2VmcGZL_T@0o+$7@n3PK`k$NKwO9a ztR$`bf35=UNS_bE9Go%|68u@i9XAhz$!nzw>i*#+S;zBJcDyeDcP)gwE{p$Dk*g?F zv4S!%sud$-BNHSa=eJm|REmcA;?)CpyQA=LEWw1fUOx@8rV#HPbOnupJB5s33;}N3 zB22app8x&a8H-0(fRD#d`03~Ug!ZQOx1Ax_5*uLV;<2gf^*L_#k~9$&Lgk6RX}B*` z)ARgNPrA-rUAmLQobVeR>=x9-T5w!lP%0@nkYUz*Jl5;OGoX=foZ;XsKkEhC(^8hY zDN@CAbvw#xBU=&nF5YmGxUS8qx_4pX*}ki{QWs8E+b`|3O4-y#rFr_I*V7QXNeY=B zVpD}s8-+duh?_DkV&nJZRsj_4;{~upgZ>*CNF+y{ESsPKxXT=?anSF?$<+(-?wYFR zedLeXHV(#H-Al;t0vKhlrN)n0rW9<7hIQI^PbYOLPVTg`SvU%B1FL2c!6Hm0>=`{}Ktdeb6_7}*OiCY}K?fEo|E((tXEs+Z z+aKy_fK9A9Bh|mzn?a95_!AnuO>G&lTEhfX)lcfCXtX%jO5NEUDmz24q$zGXZP&8o zT(lZ80M)L)QIX4QQFh3?I_fJkw90=gj_K47_>@7ae)yFTdG0V0qkLn6m+CtSsCldARQJ(0c}b00Nvy^wpou2lz1KSFH$|i^lC2n^*2x68 zER0t*yTCf@N#*5+_mWuT+w})5V4mSFYjcSNFeUo> z9ji(dJ$X5qy;pidqf5eyHKDmIpuJc)7`Pa|&QL8Gnmbug zGr&>k6el0C9GhlY7FZUrsGhn7JA73&e~5H?yc(K!O&P~nPD+`|P!$jG_hn6tt#XqGW;5rT z*x-|)Mx&NKhLTDQsIY#+X+E|pDsP-F)!D+tQLw=xzmz%TA69@=b0FU$W&mBJypGge z;5k!Yy62v79abOYO$bh^UY-HR&==&N$PZFG#=bi64j1Z(skngaEzOHfT{SQ@0b;*j z$y}`!aD;`HCQ~DotRaj?Kj~!mVTw8>-hjI5#=>=+`xW~LN!r!=7Tayr!E^>aMvU7&pzg;*LC9JhXHZDt|2Ie3f+M zK5pp(Yz8RuHyXL`uTb3!TA?|HpcKgg;GvhdlN&h2=x`yDQZ_1nH`-2cEFU^FupD?Y zS4SLauN8j#ep-Rp9t?yVHmMR^Vt|jBwkpQOr&BdU{HhXB?=AcO^7DL^F+2=1`Y*JO z&T?VfoJXAH)m$$6L%rf;#jX_HiELOzZNWrS%+A_H_P%ayE6copoVO4>?PE6U&!WdqG_Cr4KA(Y-TJT>-o3jd+~ zaU~4t6KoxlectGM(4eKSq$aRV4bu;+_hds7@;fHN3e^QD!)jpFfF){1rNr_)GxF|r ztT7tVUTiCASsJ2VfYY>KYRnP?tF8}sED6lzJk%}az{nOmO?t+q6{gn#76d>8ka)6s zp$;)$3W1qoSAxIksG=;%dO^)9OH zkrzaZo$00gh0KY$T>xCknoGF2a-lMiv%`o9n`|}T{&vn6tq(EvbMZo$OwCiSSx%W_ z9ta#srR;Iv_hEiAMjF`goEaDq{s+uiy{9GUV(GVlRF`HhnFiS?+#jxS}VPiXD( z-M#?>4KzC!vm=KGvc%A-#A1* zR{@sjN>r;_1tfaonMwL8%+mY0?lRPa-+ALR)D0dWy+Ym#IG_rfP`wS+sZbh)G-DxrQ>6)eqW(FY|$Ikws_U-T)BXdCX_M!YE``5{40X zw*2j%g2`_@gGc*JQP0bfqMY6fwlIwzdl@}IJIOjjeW;ep!u9UeQSh7`y!#@&=^*Y+ zle7iihF0t&GfwT{Z|g|tR#?&UL+ninE1L};6nq~^qiNmbY;m5-5n@UH5CciRFLVdg zILd3VtpS^gt+>}r3?Wc&Kv){%6(Kd~ift(<)%Q@FL_RLkhKkm{4eQ+-1!6RSf7)#jB9S}8Xr63%Yn z5z?`RV>x?I+#~Luezt@Pz9p2gJ%Q~&Fr~aQ-%#)#u)U%?>qoGOui<8A_oxoE^adTB z0ZC-&dakpfth9j zzrS<5Zec{?NrXELeEErJ;pl{1uvl)Wnop+9ZV z{7?^yK~Q48lJceUp%0s&cR^=v^O2@vV)2|R_|T#@OX8O)dn@vXHwP4m&Cf2McJ=&e z;^{PV2uMWa>1{FzIj_00pF18i9m42CGZmW(vVXz_AW0#M_|_nG@z4GJ;~<9ksbEj# zWT69a!vevHq{rhRzdx-VoBoTEx~5MfN#(%TZF1OqZGH+774s=|Qj6AVrXIHOZ}b7k!QhiYF%> z;?;`PA-d1)Rn7PK4Jc_|x4N5~(BQNn0lwZ?aT(aVE`PV%Z`WAr4}ikIRnNozRn+d5 z1e0AbSGcBfwsRzD_}@s~2&m^%c&jNe3d}03?{KV~Pu}Zj;;<8ZsY4u1lm-XzVZNd} z9xofO0V9ff)Ev1xoK<8q(ksMYG%q3pDODX(ht?}5Jv%vC=op;Aabt{v1Io!CZ0MIU zy#se0=HeW~mHMbT2Ik|jeO*@Msl2H1b%a#l@xS%HI7Jl60N?EY67P_udY!Wu(n_M zfZ9W>0x&P=``J4%b}|A4FdK-g0}v0AEdB44jF|8RV92cf5Enm{h{w;VkBbc4fbVC* zy8ryZqw1>hC2e!+i0zRb97heQdNlx|<~)!m-=KLd{#c&tnMbl`=)+1#-Ia?VsTzd8 zT&JITn|eW4iFz2`k>&naJgFP92{~Lqy9{!DOxcU6kQxEdM373* zmpKY9Ts#`m^X8@u>NsH{#@5s=GBk+zRLKAULKbsVZK550eA62Re(Hw$uk2f@I5 z*PYfmShq@!z7G>!ZxYXmNR_H@J^vbnfqq!^uQ<`FqkoWZGp%!w?p|rjbgOD2q&t?B z#$WKpjApPjnK_`}m4?Q=Z2}ztpS&G_je2f?lDbX)%h{C(r80&>0$y+x$h>IIB)bhN zJDB*=CePSREDVc7vzX_pCBW&!+hDc9UC_Ho&CrqUliV=3#2+BN;Ira<6;wib-q<2g zD_@IF;Ei#}!ePD+_=`Gr@}gbX=i8e*fXye-fTOo%dNQ;2v$D={O_oXv8u|LybWjt@ zQ%nL5ttGkMfgfnA?hXM~x);`9BmnMMpV3@#eagPyU~abd>sXJ#sS^WU^llxZIjYQP zL=Vyk;y_pe8sfkSZq$V`jQs}4W$oF&diqb!+{J^ZnP+T4TzK3`KwXaW<;#8Np04|w z3nwi0EgPnJLtqlXI)ZtfVJ|A8W$d=NGW(!!lDQ=~1$1o`$VP~Dt^M95gy_0giu))g zgeMlW!8&){u-^?Dqrv*?B}gwhgmTyR7Y?xI@Kzz0Vu&*aZJPh`g zF*9F5kc`Td@oaEaixc)TSXq@5_A!__auefc`)7Sae@d zJ8u7*TV(@nY`7&5&~iG;2!J4l)NVWyoLWgI4ayN;q};da$jmKPWkrR?wI*qrXww)} z3qCe{jh6o~>Rn5#0J~?AP@Ct4&cYL$j0c}&CXXr8t*EEX(lRQGy;-KXQO6*1)unA7 zTbI?NJ6Un=6eLjV{Y_R}028(=m#L}t0t#D99*Ll;og!P&Zht-77A{i}$ha<^N3qh} zm#%VH*msp$M7&SS(HI6;q=}9~t`REZMUO)?1Dzh;^7Q)K-_-NIe(QR!#(!#F$bYMF ze)}6xT!d&tH=E*Lb&B!@H3<5r>IElKB-a%)+CPv>R(qO}WJ{`yF0d%!;$0V)l-OCf z)dv_sxEHo(q0FTl^HQ|O=L3yKwl4BGauhl3T4BOC5X~{;N7n`Uaq}(JRKGJ`%T=Uc zNp$GzmY74~e9(~0p^uS56%fpPH}o&`C=uCZbtjt{zFkTNIc+b1ALYZ3t}~^qjFo0v zo_3}f0ePYU^vc+n6~pr|NPk1H3mp0n=Kg>QJiyR7_XJsQIDiSfz>ol=7C8X17fizh zYevy7k7%_>_34`8nKeAlS~VEaE-tdBFJRblU92O;(goxt4WmtcDMjy485B`k}yo)Gt&pearF z$V7yKTk)OB2fC@pw^R8YKs<`D$|vUTecHszQR}5ONXt*WO{t-wyUpr-Gb{Q_-*Txo zpQ7%>5DCS+TB#+=!Uty8yvk9!JZ9(k!XaT;%X$V-Q|iQDy~anD;$Z610+O;iJP@_T z(u`GliZv_y2cvryc!_;03+VR&GtTKUKaRL1(%gyD%yI_2Rbnmb2NYGx;yaM;A&VPB zDm|!K?e@9z8p07d1jVo6m3|yx=#*ZhI*_K(CBF8eH$C58()bQY&tg2^Y(Z?rj?xIr zz}CW@09uNwQ_WcfMC69dfT?0>4n*XF0}p5bV4-iD5XIHu2QtLk845KQmQdN#e?rXy zbCz@5(@BD}_5wISGd~)Z#Cy^w83vaT&P)a_b2{V3amLI(h~~im5$N-}5A{+0hh3vc zh<7ei|ME>(aU)az{!KV?EpvbMElDhMuz5ttG^2~#!87(CBR>LDzk)@Z7oVlR9Y~n_birrLFhrNW&q8;a?0#MNY3I8>{yu=U?}wM$hZ;%l|S*u zcmkwuIS3p|WraW1LK5HUfDEFNCW?1w9X~ccTkn@-(BP=v0NfC`B_ozZ3 zGYz|YIiV)}`~rxCQBq)JxJXZLj&+4T`%&K=#a6=DsEbtwqbbHGIn*q9M>E;ocxwLd7mnao4_3-mV=a@X8;!?7U>yf zoBfogikZ>x!pLzY%xz0`Jx(J@O|oZ;HEv&V~e7_HCLqhMA%H!WDP5HYEm_ z!L=k`TVo1J6`&N;UlY6MmW6jj5P!!GZ`-5g>Hes}6cney0j&1cqP_h63OSRdZaxRy zOqlh-cmY!LfHu^74wvXt`v91oiyV0nG%{_-CfOti=G#KF%c~Y7mczrx`x%B*MfwsWIhLDD%)f_b)J>PZ!iL03uUl*BZzMaa2F94kQ=>eXy@q z9e!Z@9X&fwLG44$M9tFK!ufanj4S-NB@@;a@)d+Lnl`*P);2kJux=}2M}`}9%Q601 zr9m8jpJxmZw;0Lk1!FMNt44*@6PMN3_XM2D3Z)Q!*CD@|2QXr*vv-o$3IA#(yv-60 zCQZ3JPV5=whZl9}hXtEHWVZqQdf-AA2{6o0S^TesDd78+4IGxO478n>Cr@X=y^?kL z?=r-)__F)5hcY=wK$Skc(Tt&v9*+^0JtgaOCWtgkbY??ngTF(hL-IqMfZbH9^QN&T zOEn9N-$Zq<8c0y9&?GXAggah&!QXh6X`-0^?vg74#wm`i*N_D|xDj@Gmv}8-dDKILon4acCO`;c9N-jBq z6gNXV@BQcLqv=zy2MRJg&Ls4~y9->7K1nc+X!tU}v5WD7H(jP^aX?nFR8j4(O8CM9 zA^VoWVf|$we;Q1opja4rowz@H(Mz0RsqA9UDywd;98>r^p91N*&V@)?@;{ov`hr`2 zHDMc@ss7ZffAO@(g-8^N=j`GJ-04u@WQXBMiN%Xhxz>DUYpU;pV%@F3hwGG7k|`0h zczl$3>Sl+$LRlb>2o};hUP=KoFFGLxpHNO38Gh8V$H>@G-Z%_V2EhRW1}Jx+?BEj0 zu()5BUFttB`#n6CVu{_VtuD#*!WuArB;8A+B!99YzDy^3B9&ZG5Q>D7oSNPn=&#FO z8G_vOc6ynw%xNWL0VWvc)G-9{*AKavQc-lV9TXTK%kVJYnZ2QLMoI!2)#R|>J5Yki zE$x&eY`&1bNStya7C}#dNNvBL69o!?Jpd;Ps?W;JFb^}%QAZ`9i?LJ{3?&^-Mp zYZY-CJdd8qJ#=C1G&{5c@kHNnp=wN;eHzFH@U~aJViY>Q@m*vz2ByH<_F62}b$%kL z{9(AJG2R1VJWzeD;BkXYQS~K^g0O>~?%_VC8Cm5$3D?3Xc;R2lG*Z!DmVH7u0b^@q zbSTZYR0We9#bn~YEc-}QU->)Ta4ZRR?{Oa41s=N0$6Zl?W3C!u(3FJ0n`0OGIDo+67R7>uvg zQ}iu~WoBNdpT>&CPI_)DbrQp`Tu?Ri-fVm{{5x zSlHMqZ5F2GFH{$1CMH*>2N{-5HcOM<^TI8(&uNPlIc9_^e*28y1X=-$dDGb`8?;!i zU@lWGSV32Zuc5XxyF`P4fCq7fq}0lvNpl7sj8W(>8?RkD4~e2?ZUg#}mv~rml0+z` zRGYOPjcH#hn3fkCFXm$jLX$%@MXea>vy=%RU4J+Nc6*!_gi)RoMM^5CTcfk`XQcBh zm&q5sj5{is}L{!08XAzB5B@nYbj`uP=D{fP(SS)TsRB~LQCFOkKVa29VSL2HFK!UDNR}1&Gdq*4FlK3iVBEePV6t`~wc~+ob?pR3**X zkt@(78!O|BB_4Q>+n1dQu^VM%B#`;o(c@PuwLE?r8xiQ3i~pu+D#z2%C=U1cC71+@ z-xIQayAedy5F)~mra66vsz2;*`a_4s8<7&e&Ki`*w6H7uTT53Jf|J5l#Vr#gv%?-$ z=AE4uA|555jw(%eF~TFL6bBXyY+y)k4`d zjh3etabSQO!s1Ai#Mt!JNQ6{(_~{NS>4}pA(uwr3cmJyYBZm5i(}U`-qYpUMJR>SG zaL8#VCYr5UW(hgxKL}@E`oGw_r|wGHuwB?4+fD}^+jghZNq219w%xI9+qP}nHfQXa z%zSyr`nK12x7OBEqkch+(pC3a$0Wp~PafkK2&v0no9Y_>_@} z4(aaoe`t2qFPfeH|IqAzYB9fPb}s?AT3))v@=nFPazz#JOv140{d>OvC5k!yp+o6B zbTN|OAKW|sn5yv;ftF1Z{^I#Y=#_$AO7Vxn@IkGRLI1$hv?CN);UOKxV-F`HoEQ{d zW-jF)3d+5IF7?F*NDi_R=52hCOZVQpiOBqpC(W7=)z7}8(u7s~Kpn^XADTVwe`xkL z$oJ8Hl)=)7tI6Z|)ha^5>e!Q!<*v0tBL|jIcKAZp`k>Z%C}fU9<`?L1((Q<@H)5%54$6w`BRoeR(8-kJ%W$%bI z2z!Xtc0c4!;#SQLZt6g1Xpf&f>hF%Mn}t84bq^&0wH~-zqDwI*LOQXHn3H~5YW5}= zq>Mjk{-TQ)Hm0C+@3N*M!eH7trmg;g7J)f>_AAkWa7>byyonsER zR+k2oMJ>LCc(i3#g!&^XpRfH5uW1zVsip{BM#&f_p%*zd7XGI^v`4N#wT1 zzw|yHKhKe`%VsGXONDW1f1#6$(31aTfhEPH?e!hnQ44ZFCHF?{W|QacMLY%Lp{Erd z4ecxZH*r%yR{(xm^23et>teK}7_SlMF z&tsR?9)=01x!#4?sMxl=u-JV2KXmtuvs0blHBmz8tJS}el|$A4w6aOaX6^+~gH=lm zN~f@4#_T0fIW`zyUZ(#k`^{^T!UW7qOTUyL6`32(EWED`R<7Y2V@fW;t|cSKw_<#v zA4!2QT`b?RNfnL*Hch~+aDHoO@3t@_;Il_pfo7 zK;YM~9jqh@o}uw~$2xdgm%Vl!Q4Wh>RG(l0H2Ppk5I=Zc;NTB5AH=AgWvyrTO92nP zC)=lw^~g5f&PT8gwg;0jNRlJTz4|sHW!~G85t3RY|zFx!+W!J71@7_@o@jj;6kT!5f7P*8GgE8 zmqN|-Mx$xrSV-s<*(@~#9hJA;xYIi~Fl3-K7-U`OR{;G{jBwOK-MLB!nGp=_yo~hx zF!MGJdi2?GSd?>9Suu;jbs!L<69jw$O$>%2ppM+ZpEByHsGa%}*5UW==<_`<|talMcqbchatDn)orL?hB$S3e5 zQnBA?R}o1G0}oSvjDfPqYzeVzviU-~NMR2TLH>W7U@36jjbq(;ZV8g)J<@xuzCBll zWEf1*@?9iMg$I4wv6>qi*6(KLVitEZbgRe4R@6D!s>o=I-&KKrX(ns98MA`9Nu!AO_7$6LNMX z?3aJf$0T%;VyW5!JuF=?9a^>&&FllFSv$Nz;Te2g{%<*0RdhcIMpV;p%3t9v*9ST5 zucxy5Jfbl6=9ry}^qo4GQ7d@Zm9u2-qLCdeo?K|g5BadY?%;IAQ4*E(yjZ#;bz0#P z@Gz-Z^0CplvHQa{g|K;TREmjzB%GM_FJZl~Pzt3}Ig*gR6Tg1Ij!$63ni@%fk;nar zBFFgj`w_&Ap7sZ4RE2vmpF8m_f(@}#Kr~zMmu*~43Dd7yt1KD?Kf?QXy7v6r{Whugi<%RJC1=y4%IbYTOlE>(1wI2DlnK?(9gd5GO zoR~h#!I8JhC!LraiG2*Y4qyB9zzW{HT+DO$;29^{Qq}#wJw_JU-G-V$SInCqFz;dcU87b4vv!j(vs_ zhr^oQ52$*xbW6Wr@Phhw2$!)mHl4eLrm_NbOQb3B-0FFO(f*hG$U<-sxYJ%2`0K+y zPf2^SBJh0-^ND^If-eCV9=Z`?-7%ry)dsC_fdkS%P;9{E?F@TeA>S7wBPIM*Smct< zzX!eri~6Y4{fU>7d2YTXDLn!z2SpRK*8|snU;~Ulv8QVWe z>^<6l^{B@+9hTwxk(jmU{nBD?hT<$7->)JfH`5>CM&H|6<5L3ll@zNO;bC*oSG8I2 zLVOLxeW4oZ_P8SK&VPSd?+jt1sSwUynn?ql3jN=AunIyO-IDnazd4#cQ6)Z%{s5}n zY;}XSw(e}N<6(Vq;_{}o#tK6eOp$GO$$q^MQjjcuVei?89nyEP7?BaA?fr(hAIs+Z zU)Vd987~TpjuEW|gyYaRfs9G?U)gMls8P&(A+zYSyS}>5;4e78kFieeRMDmKn_#U{ z+;WtD!(=TA6j>0OIne-HPD#<#_gz!QXxaMuS%|fPKvPrnJQt&#o)bmiXWyo0!qL?q z4%oNp^TM27<)AUQJ=xBi&xM@r$(?=d#*hEe-ap@|d`4X}=h@L!nrsJ_TnX`c9qL*-Yl5xc}k~9Cg^!a4Ii_7q2b>f&hU?PSljYys?AI*BsB_ z$(?5LMw&ZgW0~zzS5mM7{y@E1*|aD2T(EH!wvU&$)rJd5t9`XSo6KQKYwilYr5Ov2 zyAKVko@ge#8zj&ErNbQpLz4*oUCC%w4YfrfZ$!dA5Sk4oBw9HcH(syokT$Ah78%Bm zpyN-@rpq{ixrSiP5@f5doRTI|tn$ND@E)57p3shOB0tW?v-o!`_0(_1%dLCQ*s+F9}hgXQ^B zdJ!~&+M@Di_wS|r3$oIt62}^{)}CsaAo(SOS8AI9Mehzyf;qaOzv+yY>V(fl=3~ws zA5nt^LO$81$41_IrmC)Uq55>4fDmo`Rh^_eo6+~=un_-jaV`nd6DpzjEuAfX6?fK# z>vhVL!GI8w5K|s)n8#53hNpG&9>)+S*b{Oe#;Gj9RqFte=JUyo{m1>CVwuZp4}PHV z004*6l;0d@r90E-!D4s(fbu&nOee_cbE|cf!4O=GXji({yQ%8t=>$`wW{qP8(Y;$$xEfQj3qDnqCQ+xh zOwUcvMbF;6f0;;-6va00?cxC$LB))5+CwQNa9nteMNY=Ly4#FZ7*3hV!oz3-j+jzbffq-DxZCRa?Eo;)588 zkQD+z)9A?#rcWJ4x@}^$bG;Ad7nz@#GY^xskrM9vOaXD7KxAdd%uee!*gS$xMhP z1XXhcY=fr#>GQ{R@S4y&@3fr^RW>N$_`ukb@=H@JQQp?Hw|`0X+ww$`(QN7ReaQ+< z((P!E`u?(UbVHd%MYxuw(_rJfUJx+9*nN;3DS_SE5|(je4DC93hj#4<-MFQN&fh0= zJ{6`DgCGWlb5(WD+I-v2XkaIk(Z@4ooQa_;6=TxbuLZ_hn_PHD&?ZeMY%6T@kD30Yjga>(eGEjDXBS+&?L{joNbyK_ zztZKn8%m8Gg`I9!@axM`opG`D={kO&TQ(Hrp-0+1K{2=6pY6)4%n}S(<^k}`dmm?S z;VfhsU}Vt`847ZAgI=@;yTfZce8Qp`fP@;(#^o8G)4zlg=#p5F!9@GJDpbW28A!8c zKHV*rc0(D4GG@xvR6oOQUKnpJZin)&2M5xDl~JpzS?rVJQ(bZgeGkH91catX&O+}$ zr_I$%mi#ePLq@tn-SFEkj$Eh5=bk@;0&l=U3CKC&f>rjKO&hjRVa#FnD!b)@yXEBr z!NKn-nOF-_+r>i}uqxtO%BqB_P|*^&We4T!A8e|Riqqve?p9qn?o3B54m0Y1{vbJC z==xNoDDS}VoXtEghmc>315V={K_Z1~t*Rz$A^e;|2};_nh0f9~enGO&UAF=`?4QSB zWFIB(EO~O=L8c=zPPRODyAjAw!ECfP>Gx39zxmvQ)>eexroH$t6~h5p)o1>7`Z@vw z$ppAv#XY1ui|)1$?ys9e$Ch^=1Pwy%x(;`%iw(=!j!c6^A5t>%JvcI|JZMPwHDX9* zZL2IAOq+eS_WEB!tmQ+p&c?2beurfa)5<$O0UZ0LZ;&UyjX?vVpPy+1mN`k@aZ#D7 zhITq}vx(OC`@}mrJa6di-jWxAY^_rleWByU2Hw1 z#ZirZ4nFPSHQwYqiUX0-?{2dSJaBfJJdF{NWl(K1X|LZJzuc+-G-h-*n4EAlVaME`ROoiolRtZQD;0br`7x-cS!0};ley6u9oz1MM>84SW zw?fuO-1{k6z>>m5C2C)i5tHg^BFI)?L@=Ao|dT_$@_wRPJ z8J;NjaQ*9&?JzR7-*AECvtMY_a)NMxcY;k3i5jdNq6CA4^nNley;1r9qwnN|BiJ;E zIKk)K&C8!yBf%(Aumg`Hml4HsT%S)686h=ZYwrLHma@HvBxk1upa zZG9^PDEzKB$#f~uGZTFfbq`q;jRE;Xe558fm*+Z8~-%$ zm>B3=&-fUR&2u*k%f7B5F-LWT_!?URw5&S^g_}v7nrwkCj>a(Cj;OJP94cO9`z&2! zzP;n$*;^AC_Sb)w3EFMz^t3kphD(O2Dchc=a^_CE0QZBAYk$&xB%AnnT@N`=mMHMX z@*MeyKW_ANRu1XdPHW|A8dq>sGt2Ihy|abJ_Mgbkx+omCT8Qn~IFci?UCyR9V~(dD zDXOTtsjcVjC&s>yJtD;E7;@a)IJoUp=f>Zg zI-9j!mO=uT3cM;Qo`%V)Q+1}i7=*BWj-3KvC_Gm!WqlobmW>84jo)RlrwNmHKz4>> zy*CV<+i3CIg!?K`LeZY}#ifV*JE}rE&A%28i|yx=_&9Q|ey1|dWWF(MuQz-mM~j?I zi3?B9Z($5e@p7NPBZgp!m9gc_XtS`J#_AKtFo?E|+T7ixEF0Ta!EkJ_U%KTCp^?^{ zrPw|qy&xd{jp25;TJ4MCB#y!=aG63-6L&qmm*zFRlU^7qw$vQD$l4(MQMrHD>npVI zVtYYwhlMrzB(&EPRQ00@G6rxWa@Dm>>c79iwCVY2cy_(>rM`2xH?1&=M!N!XF4k^_ zn=@LTWG*god)`;EGFnY2Wn~$8@fx%!FjEEgv!v6FusG`MZ(gtz6@#Xj@;8CT8$>84 zX`O5)vfhI4e-j1-r+hLV@0^>ffG72y1D8bG5gDot6D+s0r7`*=kFpOM?gq-to>w73 z?ilr-4s8V4trn+Ye2jb9(-Xli=ka=O8AqV9nbo>qYqmA*aHie_b~fYbKx9SeP9fu4 z30n~ZpZ@jQI!99Zkx+WJ6KwT}l1;&>s!Q(Yfn8A(wB$EsM`)olh4-X%8=M+0$TawY z9IMuI+-~ETKl7PMPea1_K7UNKEcwiSMWyPPnkoTbw<4Do>x$>ZcLeQRK53X|-L8dx zl0|@$oh5N_LBJZmR=qd>w9iKH5SajcQxn^h=;*XX&2rF>tW8_`D zry6b&-)nB)KB<$Sv@>Mz>iCkd*6+pxnkInSyejiN$>onqkAOH^v)hq6fUzN`M>b0i zAFGhJA-p%Yj2@a0K*BsEgGN)uCCkQhAR52jO7eDMN0#44QlP8N8!^XGPw8;#Buqt> z_k#uW)Ftmdt#aAUcT2Hi3477Uy<#GbAlUWc)!~+2GRL<)Dx0mO3w;xfwC%0cRU~%zrccy73iRp;SDA-R?T+`vZ7heYAU~t7t0l-FX=k{# z%bRd20|&2B5_he|(=GJtkXot?nGmO9yjSH9<{306F<s~a_wpH3rip*;#UuGP12GY z{bn8eep}o71nhO^l5UN&AoKjK-g2|LOHZ2VJQxvON7S0z#@=+hatP}(HkJJ}r28;a zMyrMJEwN=e6%J=RGl(mqzgTBG;?ZbHK#Uhq>cjaGJJ9y$DGOP~7vK4VkRlF+i(2T1 zfSu}--CUw!KK4%J^V44e;*Hkh_dhjje%acUjwl+FK+m~jJlv# zjP-VyuB9X{yY}K{UGL;kxo1BXSh*0q(8!?nDivi?LKP zX&l{5^3zpCHT68UVYxz7Y^9b8v-<^<4$$0J&0#;h?BnZH@(N$K`o~>iy;e;x?mziF zuzVE|XdC43ffk}IO0oo6qESH$CfaWi*zPdle(M3YJMEB=%`_df;dx#~ZZwu=nQifl zx`BpzWl$KQplr;n-pSqK=c z*YuR?akG4G{881;$(jw~G3`GU;7gAza(%wlP4J~|pD?+73ZG`vIb!0;1iIW25ckCa z(yT15LTZ|H`=6YBcul2L5IkNEA|~oB%QFSxDo%%;zmH-m&jtUSC!^#$6iO!bdR~+n zk@1ALcA8quy&6D)KVEFM`%QTmhyMlWL*U6yTnVY2ow#2I4?Ah{?*X70fr4tH1M0Q~?|H@~N(^%lu1svRI~xJ7dD-6?7=uopl#8NLM7uPYxA02!fY83tkTK zaa&_I39bUz>)AVvr!TKE0@j?3kE~Ol08N1{o6ufwF}`JANqv}&#?Sv~E_ z;Z6Kv{u#K#C$xgn)jWHj)cTP@aWbMD^jbGPiFC<+;<`XlrTUc+wm+-&SYpm&_Vlb6 ze%|*`%f3G70$$D*Zbi6Qcf?~Gv22jJU;UU?I?;|M+ujj)e3<%Rnp+?pQ0?k$oO?NV z%C|O@L^)a_0x5O8N&5z6n|EyV(~jIbQ>93Ul@p+Rvz~Fy;pM4@P+$NpjzLz`KF|J@ z=r>rf8xJho@xBWr{zBgqsN}oqtc2xZeBPs}Od4W5-;+6+H`|my?{kEry187F%-#q` zAVPX3%d1)8F;(oFh1X9b$QScJB?Y6?*VNneFG-o6>XgB>A+}I#&)15j5BUx{3&B#j z+V8%fv;a6QoJ6Ru!dkb>B`r;nuN2nKly+ysn=_Y8{e5(oKCK2*yN>7fOC!KE>jqq2{@i3XjK9UY<4v(Zp(m+Cx#W{=u+Tb;`*3|-#FZm#<{!vX?j zQz}pK>zpBo&j8<}&ZOG+eBFEPMU`PAW6Nu8U-*3!d8E@i)7=%@Scx&MWf!acrfljg zZ4rNnU&ux6b{ViiE7N{xg6!)o&9Q8-va6_n!aK@TlkLQ}f6!_{3Uh8*ER@#GQG+1rhgG{W!~Q`mDSNNu$Z4ozeF;@0Z7X zP0kaD-7^V?THK`)*oW5K#g51ySoO7wd(bb7$8^AA1Z6qTAJq0_?S{-0`(*xtYV$vS z`h_6hRq!|du$+hFsZBuDG@ZPY&)c=eYw;RM5OIz0)91Nri}707o7mX_8IQHb{xYL7 zuWQJ(< zOH-d~fU4IYKWE8he>}fthK;HSrM@j2ef~*paBCunOxC;BfVduT&lvB4e&XFneLVAF zQX^F_1wA8lvvP$5*y-sOxZCVVmHwk^gWquv`DiCs_=#u>I%V?3-dSJG9l1TR=?7H3 zO?~|6SwEZ)TZ|2ixk^YD2;B|cp;681s#;CmV+#_j;0gjtzw@7)uOD_?UA$)#UOScW zuXtDiZE#F41cW?nltl}_;P>-CSWSB;?<(RDJ(~t7%4!)%sUC|gg=o)xl@k|_lD>Q$ zyYQZWGTcwf1+%}FNUR7y3bp@`6>{MVv0D$|?#ddMz5MrPN-b^7k+ zo#_akt(WSDcrbVo@}91?!(`0ggYv7A6X7kjRR}E?_v}?YZE6x7IVZ4D)IXo%SMKe@ z6Zf{fYO*g|^JicNwr#J;--!+hzW3tQ!YAqC*f=^(}B63@AFZc%TcTH88BCzjXm?Ut~syn0Vh?T znZw%7y`S{PH1L7~o2BIUEnpa)Toal+d=|$6nK~uaQ-8IlTz9(e`q5jkir(lx(>DQf z*J7D4>Y~qG80i_FTR;&e&`bI(lEBRMtq~R|?*7~kRKZ!sv0O92rE8njCY5}q+F8px zFnHh;0(WhzeT0`K&7h9Dw4XiqWD()BK?ThZbegE@Fi%)DN@*(!zc{w${Qb!Lc_=>G zDvUF(l7eLImFEo@&3+DX#os(Nj#6#eFx>E{yg6%k6#>?4m#ox+Td39$?0EE+sbgK) z?#GYtyzl^?QjC$MHu)Ef+(kzELUe6SkO&_c0k2_!gk)5pX6KTCahj=N;}0~`lw}#k z558vp?H-qRc+C+}$$FxQjEA;8bPhV}Rq2xK62klqs!R10^wr46cO!F@nuh2Wc#m`^ z>!=y0udnzY2ZWZ(Py| z_>@RXYcI%&n24Zy?a&@>jX9ewU#R{r@+;(eE@sWsL^w3XVxDgeXdtZW8j;;aC2hMi zW_mNEJb9}+!644+Z#)= zNmX=f%o8;f;Z%3nx8c`n)ODJ-Z>_22!#Mtd4#%fFqVfkN>W#^}6z&9DhJirEnp^_o ztwL2pHpYLx=^AjqD#kMSi(0O1YiUAcdpN6iha!y&xZA-~okQ$;+Re)KHRFa6AH zeEsCwz_OTM1dcA@I0B0T4@#o-{1}1H3~%=iReEOj*~# zw&}#ZIn|yk_tu~7;_^-Uq389-y`I@m`?3SNh`TTPJwU8Wa5EFx^}{jnEcsQEJD4r| z&};HGQwe~7n!dq7TM*W*wCsI;xDlXpO>j@U2{=D#rfPl_NZ_ezZJ2)@3!|%vRF!c| zW93-p?%gfgzHyXx@!Z(->Rvfei}@e={T2A)d!^aEKYfmnQW@-we6haXQR7(P*Hn|W zqw8!-7AvE@W$hL%)om7F;R=K7N^*2Q-%UG9$~mETlD^8tHH_Gpq?r`LK-<31r_5^W zIurPi*8yPFkiqi+>{mQ9RaqAE?Qpm2jfa&8u=(3O?oPc|3A7MDleaY2h8?-oxozD~ z0P!1IbP?8VFYg}82QO|DTR6%RW(piR_BPtP((8W;@yy{#l-p-<3g z?tWe)V0@;Z>N0h1r5fwlG!lWEhmNOuAv!#QK^#v1QmWd?YuES<*p6b?)joXYcgZw`S7u zynk|b$}TT_rp?qlhz$w=Eu9tLgaH6Jd8~i~j}#d#!pm!~6)Tb9#nVy-*OJO-s~yGk zHsE`w)AO*mBGKU=3WiShA7@Glu1Nu;Kum5t-);|?rXH``lRphH{D7Mgwh@TD@6+&{ zjE=zJE?>&Q^U~4PI#26_qdI>UOZ-M|8b02&b>kkhk#NzTtn9s@NZXyoPqmFt`%S!o z`wkt7Mogu1Bu@q23()V91nJM0bl(Bvvw+a*_v0`aB5Cd9x0l~JvEsmawn*RS9%qC( zwv$Tr$r$3+tMK_T&y~{k1mJsA_g1^FOMusOYNuagV$Z466u(N&ma6qUrEkYW6)owo zKz^+?s>7!eA=iT5b!U?-oh(78*OQxcQcz0mc)xT92R$}LdHq)vH}sA`W$i2kx*Gb$ zNC=j)(zlhLh6u%&-=(IqqH0`~mDreBI4=6OUg*!MWa*mEP}=V~Z@1fN>9*TV@k-$H zU6QXE`S=Gv4O?WdGY^oNirccv{!IgCHq`!=UGQhzJy@>QccAuzD+?>uRM2rv)o6VZ z`$EwF#=W}OBeU9?Cu67Yd=&D6sB9m1i>VFYP*oecDi%L^q#JWRBzyC<;$>3$(%&Vh z@33DRAMOXvI*9|`43t(scSy}0_1VM}I&=k~j0=GsR4kI0kx_OYwf?x9nVfqsjI ze(6}m_5d_h5H1L-qpoQ?eU}a+IZF{B9O0CQrz?OERBt&bcis0y zYyZ^RI9|AZfMGCvz1~oJB3>6XX{=j-B0|@!h2e|5b7Zwbzo9iZsy{e>I=Ody)+EsL zV2OUiUu3t|jMi62$eY8SHfEh8a3j4evwS!UHY4-fH*PDRWQn_T;g*?=aD zzWDcyMYR07nqT8@Aza%R2@BqTeNsO8#xB=d#zICmb28Gi9a;7ESBZQHGi(}8dVsuj zoNI$&#j_%-^8*_vpUW46J-bNaRvh96x2z_!zab4);SlV6*Fl{&c-ddGt5;qHuNlVN*UT9%ifXo&5N6BhDGh(QD=kr8n zBPYs`x{G{HmwIh28V=2t8uS(*=v)yuxo(Ur?ymfrnM#tJ2vYv3G;^BY3|AB?IOvbH zZ*F|~?*dBUhjab2Cej;(zWo|s{(B3y=8CWW4t46m*4(RPN|KK5$_^f&fkMFgttb&0 zMTa0GnZxCUEjIfBIZG?l7+9NXi0+}Q>YM5fQ#G_|_ze^=x(@u>xF zzP%5w0I_eVP_lZgT?()+cZI*NC{LQLYt&Ak$s8ZJ*0>^$o*o-1oS%KoUM<%OSFj0t z%NauvlgP3{wgfC)2G?N)5iNYHyt*x__Di=eqC}{H;j&R79h9#%SN6C6 z96u9hSw=lC~I^u`JZ=hgN5r>LVWD9 z1ZU_a-8>@3`Q9|d)-ue=I`OYv)z+-H!YA?o#e>fu6~~L)j4g#<&TCdD?dI#z=+>&N z7@voW2lGU?zGY3-NQVP|4xaJ|P}{5c+RD>q>YI>f*A$MX4sRCcak+(BA`fI{LO<;? zrSvRI4^Jc{q3}oUea_?IWP-2l`_9HrhWj1U!$2vD*rzM>M^BXOhDO&IY(}c!7eO#e zL?I#>PBF4FQHl-Fj9hQkw;4e3*X$@D5*3t2KAhG_&`q>>2CQ}kNNZ^SeRZiMHyI~g zPgAuy!*{&eTL%$tkS8;0SS(R+=+>6Cp97kZ<7-2vUPumjl==#{(ddu~PoMHXfTwZD z!)tg2sxi1N@k@^`~ z?Fl9%#}0!t_m#(2C=GVr^VR9lB9y8(uC*3DeT^8p?lw?@TMcJ_x-q*wp6_6ux6cuGJP?nsQzlNPm;2(8EKoJN%iuBTI}3@|sQfGNspf#`;halW zCxPAewN-hlXZUv~V2O1rA$#e%ZJhgBG$AwOD<3jI#m8uMpRsVKu(063?&DkeSgKcM z;QQ=yA?OR=?#Q);a14?#Iu*dKIwaIS(_ygqvCd9n?bGw-WiCi)nTX~Gza1g(}Jw>{J=9D0Q#@Ha4) zs2Te4ADA72)J60vkwQRyiGlLx2A`{g?uOjkSm6T@MU*EZzAJJh)5kCWzHTR0X4VyF zPRE8>4yU?W=0(ogz!wF$r4;zs0X9r8j0nkp?ODPj4f$0hdIrX=4(|;`e({h(`75SY z7Dl*GILtxtxQV!GB<-p6k-@ys8qivD5I>RB^&%qt!osT1#!;R9N3)&Q;Nm$%<|iQW z9sE!n|M68Kv?6lzqE z;;}f4?}lzyL+bU#7K8DQrT3=gZ9{@6az{Z@Va^e zbbB%1rWDak7bN+B%vZkz=tP?o7?FDNTq;b*s5mK;S>$t}uU4b%1IP?JZDHnZYJ{|$ zr0SAW&{SnIPqmbSSbKi@8`y_#2FHi03&;}NzSM3w=br;RYb1dJvY9aw?LHsO2ZewW zA)j}r-wykkGv<;=&&8o;44~B|;9sYHUyh^Viy?e$I6Dp(EEp$>X#<`^EX(7<#aV%Lp4v8`U*$K@n!l#I@SXI@=ZA~(+|wawdbql z3v~U_#l`5{US9EkHqZXyhwMOZSQ5r}?~m|V&cROJTwkB0z8v)eLKCxwIk*&Sr3bi_ zLi!?=_!48bZI|{d?oSz19XbEbElw|va(V*Ix<1mImY2cmS0<7XsqlF;NQ@j6$9!2rkOkpGj(_0G9h~Zf`&Rc7XokC|FpSWSSln@X<>EA6|lT_{`c9*5l-NYUqH82-t0XWiDh$}m9h@l(%75(VPkG3CcblbC^uma1 zgMWSKXOJzDY!%WsE=_vLohT;l{b0V@fzYHxN<|UF*RV=2ttn^YD8fsV7*Y0byXJXd zU+Iy3`xxY(xR6^^XB{W)9PhwreJ_U5mrbORKLtNeg9Cuq!%sW@csYD*-B+y;f9R*e zMs43jci*?--1X+7Ld^{L?2tOQ2iJ*yhz_p!ONL6YV3e*ktlMSc4{#i?v1-*K!Z6TN zb$5(nOGMqebvOpMs%Qqtj$dV-gU}XAQ26^EhuCc(vMeV1%tZPev|5ULIT;Cx7m$wS z3WG!YPd3Uj_CkP|9-%ZhZedkDH`cWl%su(6Qlw5?hL!LzmrE&+n(I?h)Vkq@@PK7- zNvDy613j$>W!j^?{HkS$l-Iz^un2I4hkj8K8jpkgQ09)b{pidybhQ+%=iwhYn5Y)i zNBKyT4%qjdksP_Y*~>5)L5zLcHrFv5j(8Q&dKJ906lxTH?G$@M5*3;K2#C1^*!rm!93ILcrJ5=9^Y1i5O< zXZXF};NL$c^c#tS+W^L>z8G{VwwphO^}J1WM*7Km)7R4Re|t?e*a|`i=DCY*U;F|h zOWFM}G3;63aH=Fb_Fx+DMcr7!a3$c53#*_g?2Xi#LKvv~_$@Sqtbn(>u!&)_$>z;} z&8VowNujKn0*;nZy$F_Jw<89dNtZn%8RGn&-FOyUiiXKk^-7eVs}In)etXGw|GR~9 zHQ6>_q>W8`7IA{ZnXn6Rr;&a(^)6hvXj9VH?&;gf)t zv5c$2%2}F~&>Q1&vg1ldNv=5MwE~3N>pBbZ7c^yM&MM}b(OFI!eAFEsI!A`%gswDe zyn7?QNC!HFp&?_HtrGq+)2A5@d>q_uV=<=xlMgNZi&GcDv+l21q0ERj-QVw(g}eby zMk5AkM(%7!^wc}dX!in82Ft5nvP|7cv&-Y71LE|U-#^TTupE~pDx1H-L*)M8tiLcf zCg(&)prZD!nYTgJdhw&{@%pf^99qy+Fd8#tP_O!zQq@=66=`P4D$X^yqCBfK34!$c z(y0K|mon)G560@2zkwqn=g=tn<;RQ$SBVjTNl%i}m}- z!Sc+cx|f|_TrD2ZL2o6VWuW8 ztdLs~MPwKZ+n|CAu^H@Jv_DlSh9~AcMUhcqtMOF4!*~Csf$abw%MDTF-B$4a?Hm^` zJ}>m|AM?6!SJ7+ke@CR(kfD`F%=~@pX#E0JFu7kYR%$$Q;(w%|4wuxT0PF1&nt=w& z;qKOJAS7^Vv90mjd5*~Vw~sko9!}H4CVlB4nx+x4z{p%bK{B&mbb<#+g;Bc-z5KB6 zPez?pYZW1TP5;=~=pi<~mtYUZY;~vt9Yx~Z5_t_soJ+NW&jkkIT8N|nwyVy^0(Rou zS&={Jv{}J3?8%>|hY^3JM3UOE`x)9jsv-LPeDjKm_$g`>?d?r)aq$Hn=KLGg;frg1 z4}4=3f}5Ez(gFqvK>_p0&H_uN*&Q>&3H$X{1}1ASmSpuG`EvW@it&(*@#FZjdhsBq zD+Mt5quZn=F)U5vy8bEhejjnvIg5D_PMPkDi6_2@4wz_Va2wIOWQ2IHG}9luw9w(e z89^jrTYXJ^59;}LVI!W2Uots72`e3C6-1G07#Ek7dqtubCl3JI&#Z_?G}3Q6VKOS1 zCmjyMCL7os^`_UZha_7r#5$H|8X6**u-lMOO7IQ9AZ2MDa6or;E27(dy`E-!kH>Nb z44foZ4~iJq=jGU;8O+dj!KEt7o>@qJ_UkHI&Z35Q)($Y??^nj$R@tdq=2asmz-o6O z7s!zJcT|NqfI;G|zafm=>_Wbhr4(%a`_qM1$AWJ*iXOujFz7BrW0Ef%A+y|ZYmbc4i&AV-o}S_@H8i*aViz1#m+)!XDadjQ(u43^1=jMSH~31oRt?9BIh5|DY&+zFL+Wt1_o1nL z4W6f{I(0$+ui=0iiyz}_l2b!YF9ak}rH&$eSCl?bWZBItWOdapH4N!b>Z)DhU@+OE zAq0;s;XuJF5?@{}WXh|R%F(!0?8xJEziLizRyO2pjByW>RCX$mpS6Cz3yo78IU&;(JwZ&M-;0Mp0f|);|o)yfAEK3vVhZB~0MgG(dwADOb^{w~Kh_(DyM0iAi%6My)({hk(72ayeept3P|fe? z^hR;L(Ykk3G|Y8f9UCy44`k4Uc2}Y*nM@-9Ci=aEJ@N!kVplmFgSr=XLEScQ5(oi? z{uHv-OVi4r17=^EYNwN&Vx&_sXr~Pe58Y@}+h{-xuboJF8P*J&*yO_C-VF##vmcLH zlw%pSw%=lMdtgXfgJFT8u-MFWHevQ>fD81)qJ;++7q?9)zu~J5rYO1sK9L3TH-?n{ z2{{N)=j?PCW2C?V{=9S)Q7*7=tNdGmH-je>vWhG#Q?RJTFp?mg?^>uUFP2k57|mpY z6aOGWL)iP`mZu;uW|bfm?qxC#G)XJJ&xM{Aa1_<%O)#^WgXPuHVBk-THgsqrM#?N8 ztS7)X;SCKYxuw=5jObkY!T3u-ACY5QI)`grLk6j6=ZY(uRY=0YySM*3pcz{#F5}=C zSCSQX4HBzRs#t&Zl)M#^6;~6EuKrnIR-%A;%6>;6EAAz15zSf^kPVjl+xtj$ccIzE(ih>zrAP+9_ zi{>U0A~m!G`R(5-5z8)n~Ndm!mIcgiZeFc{`=txdM=8!SrX` zxm-o6awdPp#_QOR&t!G|*8A9x380M8-q3y!TZd=}z9scWK+^KiQA;+)vqg~o>fp9# z#!Lr(8z*J7*$BEAI4T&^qW8tdnXnxlIHKg2BA%8!xs6MVIckJB{YU#E(G8If6C2}0 z`M?yoEu}|`n&$?#Y=rpJ^g;bbZ5Fo)lM~&4x*to4t??(f@M*LRf-Cq@-kdm@U_H7# zsh|T@Etwx4Br=5^cCU$9f*JTt51RJ3@LAmFQ>#czO|(>_cQrd?<2^QhTK3`fX~@%m z(YS^JIbfJ1mKgllO>oQixnp7&Fb|uMD?TK%^G*d}6!GcP`#19SG|9SV>C+9rL*R~h z^ENq#IDO5-0Smo|DI4iS!YXS+i1!bqiG(JCT4?PC!By*11SzlBxX>DddBfD>`Ej)@ z=SXsaCa507x45yDXa~(n`*fpVUD&#)o@8khBlF*#!Kr^O(0jLjIr|gpnZu{~6v;Q^ z=o|NuOCEHBtj#_MwQzoZ%W5-E-@NCTEt8xj8^_=3a*@_;rNh>9DI%?a5f^5*#doJu|R^^P*{o!YERm^ zQn+1X^4_Hd3ZO7&6VwShus~f{tTU<0qsCAei$)x1x5XH1)(mweSThrhxk1>%*aCvJ zfY639CsT}hpdJL9ZH6&V)Qey*%`xVWk_lFBfw5MoAHhx$tS#zKu+IbwMyUq9hoKCE z-osIrfs_b{C^b@|AdX?o&I)5ONJX$ng2h9QEk-GvWUxsdCj~}6l%oVVmXiyVDV%(O zTRA#_Cpbj_9k^vs+mt&F%E{bmP|oDe0(cdm7*(34K)mAeF0szStBE`g?2OZSLV$Bg?INBdl<)F<0Dj=j0?Jf=XUYYw;m1;9w40v*uvq*F zHt{xsxxf=CSPHcQ;aN%s{oaOhsPI1UtP_f8F}fx+r}-$s=n=qPM)?SrojA2A5vJXM zvexV^lsB0P!P_sHy#dNyvkw3tntcKI%*+T@dZy7^BH;tVJXg3_0_IOJy1~ViR37Hc zSHxfP`j^GE2rwV zH6wZ|!E5vn>Nna7<|W#N!LHL1#6`zhtcq>{+-{8-jOO^mJ~M#Dgq$|W2<0=FksT)( zFdbXx!wCbdgka^UEhh#UqsastX&=E!f}QtLE$kD)h5_s|nNJYVI%Kc~_b;byzcNbgL;-x0{;;SchheE(ZywW3jUYOLAkd zi`=t-%_X`_MpI1FIX39HTaBK!=q15s2+es{0ejE1BU;-cVT&5g>`?y}Oz%?OEr`bl zTGZ(2h#I-q=-CJzaAW%0W1h}wgqo4M$@ab$O?VRI>#pzJgpwc~gAuJ=k-bOF_*_wz zhn`bHxuQY_6RzYnqneo$4RScw=6 zVl?idC8fs>Q7!mM$gLXd!VjWqupazy${qbutyvO8#Us^NZ^{GRsK)wJp6HE--nv;7 zoaa3m%?|T(0TZ&=dA<2g*c09iGC;8 z4D^ye3oxz^ z+8}$WzV0z#0aE>FUs7#Rmb7L>ZIMJ)Gop6ry{yKUI-oG$8t(~3w|r|x8;WN6)r>X* zt@UH-dJ6xdBG6918qFfn0fHT(`U`0~5`FZqsq2X70E`V|F%yDK6+RVO(;ZPfiy7G0>kaBUqit;6 zS(A30&PZ$!HM*b%42C+IR?%HhrzSOZ(I|((&^t3zZZwK#F*EZdIEVzdsNsx79T^PS zTVTw>)3DB-!O#YacAQvr)u1j8-DT_USyVypyvwVmE*@QHFk~yPqT|t@EaoLng8bnC zi-i;Hk#|kIuIMF$p*`Ye{H`d+z?Tw{j=@m5;lpH+Gp;gz3a zR71%$s$EMVRXqyBKajxT1ok4eDMVU=0VT5zg+lX9YubLV)%PTPk3QBw69!HqJTsXd zNqG_}FDGzqHKftj@AUikV;TM(7%Kd?(!M8oFM&r5WIi&kfsajU%1!az1@bVjOK0FY zF|Lg;ty^aJJVpsbKsQ9h0`k+$~-6w;VFWg&KPzV6QG*_ZVI`w8D#DuR0PMJ ziXyNpfxQTn6R0FGpTJ@Q%KMW5+#_pK*pM8(wuVz_yu(wM$QVp48EpEJ$ow4fiG=5v~mz8VmHWVET-2#%OU?s9~+ z^(1tE0v8e(NE4eNykjVlkJ(&K5YX3gqUc1k{hY3(R*CY>nnNx&-0U-5j>efC<9I^( zB=Af#yUYnkSkGvZ<3*D^FbT%k6rv!`c%w-M7)|oYXp-eBk(c>gDC4|$1KDwU(Lv@? z;K$ixG>MsV7->uH8LEqU5I33VnM~v)lU|aEoGWB5l1VSgq~BgN!-@Nnvt=wZne>%R zVskocAKb4JcoMh^5zc6u5S_~rwr~qV@kC1V9IhwIH^<{GfpR!1GcN!*&U_Hpk;oAv zoXsvoSbu-Q>5qOi9}DG0Fp6-r!aNuto^emK)qDpxhvdvTB!A8!xwH;y-*X3(F%Bm5 z!GtHDW+<3vFxe}HBb=2DC)v?Ba=IBuPCetusb?HH^^7AYopI!(Q%twz`0%2zC3)k> zIVg$_v$)JDr(-R`c`lU7qBCzADzqrz≪^$@DK4!Egq~dH!5-nwU%USppi4fm%Gq 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 + + + Rx-PlatformServices + 2.1.30214.0 + Reactive Extensions - Platform Services Library + Microsoft Corporation + Microsoft Corporation + http://go.microsoft.com/fwlink/?LinkID=261272 + http://go.microsoft.com/fwlink/?LinkID=261273 + http://go.microsoft.com/fwlink/?LinkId=261274 + true + Reactive Extensions Platform Services Library used to access platform-specific functionality and enlightenment services. + Microsoft Corporation © 2012 + en-us + Rx Reactive Extensions Observable LINQ Events + + + + + + + + + + \ No newline at end of file diff --git a/packages/Rx-PlatformServices.2.1.30214.0/content/Net40/_._ b/packages/Rx-PlatformServices.2.1.30214.0/content/Net40/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/Rx-PlatformServices.2.1.30214.0/content/Net45/_._ b/packages/Rx-PlatformServices.2.1.30214.0/content/Net45/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/Rx-PlatformServices.2.1.30214.0/content/NetCore45/_._ b/packages/Rx-PlatformServices.2.1.30214.0/content/NetCore45/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/Rx-PlatformServices.2.1.30214.0/content/Portable-Net45+WinRT45+WP8/Readme.txt b/packages/Rx-PlatformServices.2.1.30214.0/content/Portable-Net45+WinRT45+WP8/Readme.txt new file mode 100644 index 000000000..88acdb41a --- /dev/null +++ b/packages/Rx-PlatformServices.2.1.30214.0/content/Portable-Net45+WinRT45+WP8/Readme.txt @@ -0,0 +1,16 @@ +Portable libraries built using Rx do not include the System.Reactive.PlatformServices assembly +containing "platform enlightenments" that depend on platform-specific functionality. (Doing so +would prevent the library to be portable due to the dependencies on a specific platform.) + +When including the resulting portable library in another project, please include the platform's +System.Reactive.PlatformServices assembly in order to get the best performance. To include this +assembly, use any of the following options: + +1. Select the System.Reactive.PlatformServices assembly from the Visual Studio "Add Reference" + dialog. This option works for Windows Store apps, .NET 4.5, and Windows Phone 8 projects. + +2. For Windows Store apps and Windows Phone 8 projects, use the Reactive Extensions Extension SDK + which can be found in the "Add Reference" dialog. + +3. Use NuGet to include the Rx-Main package (or any package that depends on Rx-Main, such as + Rx-Xaml) which will automatically include the Rx-PlatformServices enlightenment package. diff --git a/packages/Rx-PlatformServices.2.1.30214.0/content/SL4-WindowsPhone71/_._ b/packages/Rx-PlatformServices.2.1.30214.0/content/SL4-WindowsPhone71/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/Rx-PlatformServices.2.1.30214.0/content/SL4/_._ b/packages/Rx-PlatformServices.2.1.30214.0/content/SL4/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/Rx-PlatformServices.2.1.30214.0/content/SL5/_._ b/packages/Rx-PlatformServices.2.1.30214.0/content/SL5/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/Rx-PlatformServices.2.1.30214.0/content/WP8/_._ b/packages/Rx-PlatformServices.2.1.30214.0/content/WP8/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/Rx-PlatformServices.2.1.30214.0/lib/Net40/System.Reactive.PlatformServices.XML b/packages/Rx-PlatformServices.2.1.30214.0/lib/Net40/System.Reactive.PlatformServices.XML new file mode 100644 index 000000000..fcb42c0c5 --- /dev/null +++ b/packages/Rx-PlatformServices.2.1.30214.0/lib/Net40/System.Reactive.PlatformServices.XML @@ -0,0 +1,378 @@ + + + + System.Reactive.PlatformServices + + + +

            + Represents an object that schedules units of work on a designated thread. + + + + + Counter for diagnostic purposes, to name the threads. + + + + + Thread factory function. + + + + + Stopwatch for timing free of absolute time dependencies. + + + + + Thread used by the event loop to run work items on. No work should be run on any other thread. + If ExitIfEmpty is set, the thread can quit and a new thread will be created when new work is scheduled. + + + + + Gate to protect data structures, including the work queue and the ready list. + + + + + Semaphore to count requests to re-evaluate the queue, from either Schedule requests or when a timer + expires and moves on to the next item in the queue. + + + + + Queue holding work items. Protected by the gate. + + + + + Queue holding items that are ready to be run as soon as possible. Protected by the gate. + + + + + Work item that will be scheduled next. Used upon reevaluation of the queue to check whether the next + item is still the same. If not, a new timer needs to be started (see below). + + + + + Disposable that always holds the timer to dispatch the first element in the queue. + + + + + Flag indicating whether the event loop should quit. When set, the event should be signaled as well to + wake up the event loop thread, which will subsequently abandon all work. + + + + + Creates an object that schedules units of work on a designated thread. + + + + + Creates an object that schedules units of work on a designated thread, using the specified factory to control thread creation options. + + Factory function for thread creation. + is null. + + + + Schedules an action to be executed after dueTime. + + 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. + The scheduler has been disposed and doesn't accept new work. + + + + Schedules a periodic piece of work on the designated thread. + + 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 TimeSpan.Zero. + The scheduler has been disposed and doesn't accept new work. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Ends the thread associated with this scheduler. All remaining work in the scheduler queue is abandoned. + + + + + Ensures there is an event loop thread running. Should be called under the gate. + + + + + Event loop scheduled on the designated event loop thread. The loop is suspended/resumed using the event + which gets set by calls to Schedule, the next item timer, or calls to Dispose. + + + + + Indicates whether the event loop thread is allowed to quit when no work is left. If new work + is scheduled afterwards, a new event loop thread is created. This property is used by the + NewThreadScheduler which uses an event loop for its recursive invocations. + + + + + Represents an object that schedules each unit of work on a separate thread. + + + + + Creates an object that schedules each unit of work on a separate thread. + + + + + Creates an object that schedules each unit of work on a separate thread. + + Factory function for thread creation. + is null. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Schedules a long-running task by creating a new thread. Cancellation happens through polling. + + 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. + + + + Schedules a periodic piece of work by creating a new thread that goes to sleep when work has been dispatched and wakes up again at the next periodic due time. + + 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 TimeSpan.Zero. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Gets an instance of this scheduler that uses the default Thread constructor. + + + + + Provides access to the platform enlightenments used by other Rx libraries to improve system performance and + runtime efficiency. While Rx can run without platform enlightenments loaded, it's recommended to deploy the + System.Reactive.PlatformServices assembly with your application and call during application startup to ensure enlightenments are properly loaded. + + + + + Ensures that the calling assembly has a reference to the System.Reactive.PlatformServices assembly with + platform enlightenments. If no reference is made from the user code, it's possible for the build process + to drop the deployment of System.Reactive.PlatformServices, preventing its runtime discovery. + + + true if the loaded enlightenment provider matches the provided defined in the current assembly; false + otherwise. When a custom enlightenment provider is installed by the host, false will be returned. + + + + + Represents an object that schedules units of work on the Task Parallel Library (TPL) task pool. + + Instance of this type using the default TaskScheduler to schedule work on the TPL task pool. + + + + Creates an object that schedules units of work using the provided TaskFactory. + + Task factory used to create tasks to run units of work. + is null. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Schedules a long-running task by creating a new task using TaskCreationOptions.LongRunning. Cancellation happens through polling. + + 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. + + + + Gets a new stopwatch ob ject. + + New stopwatch object; started at the time of the request. + + + + Schedules a periodic piece of work by running a platform-specific timer to create tasks periodically. + + 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 TimeSpan.Zero. + + + + Gets an instance of this scheduler that uses the default TaskScheduler. + + + + + Represents an object that schedules units of work on the CLR thread pool. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a System.Threading.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. + + + + Schedules a long-running task by creating a new thread. Cancellation happens through polling. + + 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. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Schedules a periodic piece of work, using a System.Threading.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 or equal to zero. + + + + Gets the singleton instance of the CLR thread pool scheduler. + + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to The WinRT thread pool doesn't support creating periodic timers with a period below 1 millisecond.. + + + + diff --git a/packages/Rx-PlatformServices.2.1.30214.0/lib/Net40/System.Reactive.PlatformServices.dll b/packages/Rx-PlatformServices.2.1.30214.0/lib/Net40/System.Reactive.PlatformServices.dll new file mode 100644 index 0000000000000000000000000000000000000000..f48d9cb1d0dc73520b3e1261fb646b75bdbb8ff2 GIT binary patch literal 37448 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 literal 0 HcmV?d00001 diff --git a/packages/Rx-PlatformServices.2.1.30214.0/lib/Net45/System.Reactive.PlatformServices.XML b/packages/Rx-PlatformServices.2.1.30214.0/lib/Net45/System.Reactive.PlatformServices.XML new file mode 100644 index 000000000..fcb42c0c5 --- /dev/null +++ b/packages/Rx-PlatformServices.2.1.30214.0/lib/Net45/System.Reactive.PlatformServices.XML @@ -0,0 +1,378 @@ + + + + System.Reactive.PlatformServices + + + + + Represents an object that schedules units of work on a designated thread. + + + + + Counter for diagnostic purposes, to name the threads. + + + + + Thread factory function. + + + + + Stopwatch for timing free of absolute time dependencies. + + + + + Thread used by the event loop to run work items on. No work should be run on any other thread. + If ExitIfEmpty is set, the thread can quit and a new thread will be created when new work is scheduled. + + + + + Gate to protect data structures, including the work queue and the ready list. + + + + + Semaphore to count requests to re-evaluate the queue, from either Schedule requests or when a timer + expires and moves on to the next item in the queue. + + + + + Queue holding work items. Protected by the gate. + + + + + Queue holding items that are ready to be run as soon as possible. Protected by the gate. + + + + + Work item that will be scheduled next. Used upon reevaluation of the queue to check whether the next + item is still the same. If not, a new timer needs to be started (see below). + + + + + Disposable that always holds the timer to dispatch the first element in the queue. + + + + + Flag indicating whether the event loop should quit. When set, the event should be signaled as well to + wake up the event loop thread, which will subsequently abandon all work. + + + + + Creates an object that schedules units of work on a designated thread. + + + + + Creates an object that schedules units of work on a designated thread, using the specified factory to control thread creation options. + + Factory function for thread creation. + is null. + + + + Schedules an action to be executed after dueTime. + + 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. + The scheduler has been disposed and doesn't accept new work. + + + + Schedules a periodic piece of work on the designated thread. + + 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 TimeSpan.Zero. + The scheduler has been disposed and doesn't accept new work. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Ends the thread associated with this scheduler. All remaining work in the scheduler queue is abandoned. + + + + + Ensures there is an event loop thread running. Should be called under the gate. + + + + + Event loop scheduled on the designated event loop thread. The loop is suspended/resumed using the event + which gets set by calls to Schedule, the next item timer, or calls to Dispose. + + + + + Indicates whether the event loop thread is allowed to quit when no work is left. If new work + is scheduled afterwards, a new event loop thread is created. This property is used by the + NewThreadScheduler which uses an event loop for its recursive invocations. + + + + + Represents an object that schedules each unit of work on a separate thread. + + + + + Creates an object that schedules each unit of work on a separate thread. + + + + + Creates an object that schedules each unit of work on a separate thread. + + Factory function for thread creation. + is null. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Schedules a long-running task by creating a new thread. Cancellation happens through polling. + + 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. + + + + Schedules a periodic piece of work by creating a new thread that goes to sleep when work has been dispatched and wakes up again at the next periodic due time. + + 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 TimeSpan.Zero. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Gets an instance of this scheduler that uses the default Thread constructor. + + + + + Provides access to the platform enlightenments used by other Rx libraries to improve system performance and + runtime efficiency. While Rx can run without platform enlightenments loaded, it's recommended to deploy the + System.Reactive.PlatformServices assembly with your application and call during application startup to ensure enlightenments are properly loaded. + + + + + Ensures that the calling assembly has a reference to the System.Reactive.PlatformServices assembly with + platform enlightenments. If no reference is made from the user code, it's possible for the build process + to drop the deployment of System.Reactive.PlatformServices, preventing its runtime discovery. + + + true if the loaded enlightenment provider matches the provided defined in the current assembly; false + otherwise. When a custom enlightenment provider is installed by the host, false will be returned. + + + + + Represents an object that schedules units of work on the Task Parallel Library (TPL) task pool. + + Instance of this type using the default TaskScheduler to schedule work on the TPL task pool. + + + + Creates an object that schedules units of work using the provided TaskFactory. + + Task factory used to create tasks to run units of work. + is null. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Schedules a long-running task by creating a new task using TaskCreationOptions.LongRunning. Cancellation happens through polling. + + 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. + + + + Gets a new stopwatch ob ject. + + New stopwatch object; started at the time of the request. + + + + Schedules a periodic piece of work by running a platform-specific timer to create tasks periodically. + + 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 TimeSpan.Zero. + + + + Gets an instance of this scheduler that uses the default TaskScheduler. + + + + + Represents an object that schedules units of work on the CLR thread pool. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a System.Threading.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. + + + + Schedules a long-running task by creating a new thread. Cancellation happens through polling. + + 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. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Schedules a periodic piece of work, using a System.Threading.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 or equal to zero. + + + + Gets the singleton instance of the CLR thread pool scheduler. + + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to The WinRT thread pool doesn't support creating periodic timers with a period below 1 millisecond.. + + + + diff --git a/packages/Rx-PlatformServices.2.1.30214.0/lib/Net45/System.Reactive.PlatformServices.dll b/packages/Rx-PlatformServices.2.1.30214.0/lib/Net45/System.Reactive.PlatformServices.dll new file mode 100644 index 0000000000000000000000000000000000000000..ae7d1e304bb0adbaac824d7de7db072e534e4da4 GIT binary patch literal 37960 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 UMS@RGW|zfYuH3+|-favF0HAq}KL7v# literal 0 HcmV?d00001 diff --git a/packages/Rx-PlatformServices.2.1.30214.0/lib/NetCore45/System.Reactive.PlatformServices.XML b/packages/Rx-PlatformServices.2.1.30214.0/lib/NetCore45/System.Reactive.PlatformServices.XML new file mode 100644 index 000000000..3bbe4b1e5 --- /dev/null +++ b/packages/Rx-PlatformServices.2.1.30214.0/lib/NetCore45/System.Reactive.PlatformServices.XML @@ -0,0 +1,376 @@ + + + + System.Reactive.PlatformServices + + + + + Represents an object that schedules units of work on a designated thread. + + + + + Counter for diagnostic purposes, to name the threads. + + + + + Thread factory function. + + + + + Stopwatch for timing free of absolute time dependencies. + + + + + Thread used by the event loop to run work items on. No work should be run on any other thread. + If ExitIfEmpty is set, the thread can quit and a new thread will be created when new work is scheduled. + + + + + Gate to protect data structures, including the work queue and the ready list. + + + + + Semaphore to count requests to re-evaluate the queue, from either Schedule requests or when a timer + expires and moves on to the next item in the queue. + + + + + Queue holding work items. Protected by the gate. + + + + + Queue holding items that are ready to be run as soon as possible. Protected by the gate. + + + + + Work item that will be scheduled next. Used upon reevaluation of the queue to check whether the next + item is still the same. If not, a new timer needs to be started (see below). + + + + + Disposable that always holds the timer to dispatch the first element in the queue. + + + + + Flag indicating whether the event loop should quit. When set, the event should be signaled as well to + wake up the event loop thread, which will subsequently abandon all work. + + + + + Creates an object that schedules units of work on a designated thread. + + + + + Schedules an action to be executed after dueTime. + + 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. + The scheduler has been disposed and doesn't accept new work. + + + + Schedules a periodic piece of work on the designated thread. + + 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 TimeSpan.Zero. + The scheduler has been disposed and doesn't accept new work. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Ends the thread associated with this scheduler. All remaining work in the scheduler queue is abandoned. + + + + + Ensures there is an event loop thread running. Should be called under the gate. + + + + + Event loop scheduled on the designated event loop thread. The loop is suspended/resumed using the event + which gets set by calls to Schedule, the next item timer, or calls to Dispose. + + + + + Indicates whether the event loop thread is allowed to quit when no work is left. If new work + is scheduled afterwards, a new event loop thread is created. This property is used by the + NewThreadScheduler which uses an event loop for its recursive invocations. + + + + + Represents an object that schedules each unit of work on a separate thread. + + + + + Creates an object that schedules each unit of work on a separate thread. + + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Schedules a long-running task by creating a new thread. Cancellation happens through polling. + + 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. + + + + Schedules a periodic piece of work by creating a new thread that goes to sleep when work has been dispatched and wakes up again at the next periodic due time. + + 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 TimeSpan.Zero. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Gets an instance of this scheduler that uses the default Thread constructor. + + + + + Represents an object that schedules units of work on the Windows Runtime thread pool. + + Singleton instance of this type exposed through this static property. + + + + Constructs a ThreadPoolScheduler that schedules units of work on the Windows ThreadPool. + + + + + Constructs a ThreadPoolScheduler that schedules units of work on the Windows ThreadPool with the given priority. + + Priority for scheduled units of work. + + + + Constructs a ThreadPoolScheduler 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. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a Windows.System.Threading.ThreadPoolTimer 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. + + + + Schedules a periodic piece of work, using a Windows.System.Threading.ThreadPoolTimer 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. + + + + Gets the singleton instance of the Windows Runtime thread pool scheduler. + + + + + Gets the priority at which work is scheduled. + + + + + Gets the options that configure how work is scheduled. + + + + + Provides access to the platform enlightenments used by other Rx libraries to improve system performance and + runtime efficiency. While Rx can run without platform enlightenments loaded, it's recommended to deploy the + System.Reactive.PlatformServices assembly with your application and call during application startup to ensure enlightenments are properly loaded. + + + + + Ensures that the calling assembly has a reference to the System.Reactive.PlatformServices assembly with + platform enlightenments. If no reference is made from the user code, it's possible for the build process + to drop the deployment of System.Reactive.PlatformServices, preventing its runtime discovery. + + + true if the loaded enlightenment provider matches the provided defined in the current assembly; false + otherwise. When a custom enlightenment provider is installed by the host, false will be returned. + + + + + Represents an object that schedules units of work on the Task Parallel Library (TPL) task pool. + + Instance of this type using the default TaskScheduler to schedule work on the TPL task pool. + + + + Creates an object that schedules units of work using the provided TaskFactory. + + Task factory used to create tasks to run units of work. + is null. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Schedules a long-running task by creating a new task using TaskCreationOptions.LongRunning. Cancellation happens through polling. + + 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. + + + + Gets a new stopwatch ob ject. + + New stopwatch object; started at the time of the request. + + + + Schedules a periodic piece of work by running a platform-specific timer to create tasks periodically. + + 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 TimeSpan.Zero. + + + + Gets an instance of this scheduler that uses the default TaskScheduler. + + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to The WinRT thread pool doesn't support creating periodic timers with a period below 1 millisecond.. + + + + diff --git a/packages/Rx-PlatformServices.2.1.30214.0/lib/NetCore45/System.Reactive.PlatformServices.dll b/packages/Rx-PlatformServices.2.1.30214.0/lib/NetCore45/System.Reactive.PlatformServices.dll new file mode 100644 index 0000000000000000000000000000000000000000..6ec3489438bc2aa5fc65e2e96e54d356d2595ee3 GIT binary patch literal 40544 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 + + + System.Reactive.PlatformServices + + + + + Represents an object that schedules units of work on a designated thread. + + + + + Counter for diagnostic purposes, to name the threads. + + + + + Thread factory function. + + + + + Stopwatch for timing free of absolute time dependencies. + + + + + Thread used by the event loop to run work items on. No work should be run on any other thread. + If ExitIfEmpty is set, the thread can quit and a new thread will be created when new work is scheduled. + + + + + Gate to protect data structures, including the work queue and the ready list. + + + + + Semaphore to count requests to re-evaluate the queue, from either Schedule requests or when a timer + expires and moves on to the next item in the queue. + + + + + Queue holding work items. Protected by the gate. + + + + + Queue holding items that are ready to be run as soon as possible. Protected by the gate. + + + + + Work item that will be scheduled next. Used upon reevaluation of the queue to check whether the next + item is still the same. If not, a new timer needs to be started (see below). + + + + + Disposable that always holds the timer to dispatch the first element in the queue. + + + + + Flag indicating whether the event loop should quit. When set, the event should be signaled as well to + wake up the event loop thread, which will subsequently abandon all work. + + + + + Creates an object that schedules units of work on a designated thread. + + + + + Creates an object that schedules units of work on a designated thread, using the specified factory to control thread creation options. + + Factory function for thread creation. + is null. + + + + Schedules an action to be executed after dueTime. + + 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. + The scheduler has been disposed and doesn't accept new work. + + + + Schedules a periodic piece of work on the designated thread. + + 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 TimeSpan.Zero. + The scheduler has been disposed and doesn't accept new work. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Ends the thread associated with this scheduler. All remaining work in the scheduler queue is abandoned. + + + + + Ensures there is an event loop thread running. Should be called under the gate. + + + + + Event loop scheduled on the designated event loop thread. The loop is suspended/resumed using the event + which gets set by calls to Schedule, the next item timer, or calls to Dispose. + + + + + Indicates whether the event loop thread is allowed to quit when no work is left. If new work + is scheduled afterwards, a new event loop thread is created. This property is used by the + NewThreadScheduler which uses an event loop for its recursive invocations. + + + + + Represents an object that schedules each unit of work on a separate thread. + + + + + Creates an object that schedules each unit of work on a separate thread. + + + + + Creates an object that schedules each unit of work on a separate thread. + + Factory function for thread creation. + is null. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Schedules a long-running task by creating a new thread. Cancellation happens through polling. + + 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. + + + + Schedules a periodic piece of work by creating a new thread that goes to sleep when work has been dispatched and wakes up again at the next periodic due time. + + 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 TimeSpan.Zero. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Gets an instance of this scheduler that uses the default Thread constructor. + + + + + Provides access to the platform enlightenments used by other Rx libraries to improve system performance and + runtime efficiency. While Rx can run without platform enlightenments loaded, it's recommended to deploy the + System.Reactive.PlatformServices assembly with your application and call during application startup to ensure enlightenments are properly loaded. + + + + + Ensures that the calling assembly has a reference to the System.Reactive.PlatformServices assembly with + platform enlightenments. If no reference is made from the user code, it's possible for the build process + to drop the deployment of System.Reactive.PlatformServices, preventing its runtime discovery. + + + true if the loaded enlightenment provider matches the provided defined in the current assembly; false + otherwise. When a custom enlightenment provider is installed by the host, false will be returned. + + + + + Represents an object that schedules units of work on the CLR thread pool. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a System.Threading.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. + + + + Schedules a long-running task by creating a new thread. Cancellation happens through polling. + + 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. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Schedules a periodic piece of work, using a System.Threading.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 or equal to zero. + + + + Gets the singleton instance of the CLR thread pool scheduler. + + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to The WinRT thread pool doesn't support creating periodic timers with a period below 1 millisecond.. + + + + diff --git a/packages/Rx-PlatformServices.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.PlatformServices.dll b/packages/Rx-PlatformServices.2.1.30214.0/lib/SL4-WindowsPhone71/System.Reactive.PlatformServices.dll new file mode 100644 index 0000000000000000000000000000000000000000..2cd85b666c25c0c96906f4fedac245104d2b08c1 GIT binary patch literal 40016 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 YLP=1AtJPRp_FV*yC+*lSB|{*;0Tj@?tpET3 literal 0 HcmV?d00001 diff --git a/packages/Rx-PlatformServices.2.1.30214.0/lib/SL4/_._ b/packages/Rx-PlatformServices.2.1.30214.0/lib/SL4/_._ new file mode 100644 index 000000000..e69de29bb diff --git a/packages/Rx-PlatformServices.2.1.30214.0/lib/SL5/System.Reactive.PlatformServices.XML b/packages/Rx-PlatformServices.2.1.30214.0/lib/SL5/System.Reactive.PlatformServices.XML new file mode 100644 index 000000000..32b224446 --- /dev/null +++ b/packages/Rx-PlatformServices.2.1.30214.0/lib/SL5/System.Reactive.PlatformServices.XML @@ -0,0 +1,354 @@ + + + + System.Reactive.PlatformServices + + + + + Represents an object that schedules units of work on a designated thread. + + + + + Counter for diagnostic purposes, to name the threads. + + + + + Thread factory function. + + + + + Stopwatch for timing free of absolute time dependencies. + + + + + Thread used by the event loop to run work items on. No work should be run on any other thread. + If ExitIfEmpty is set, the thread can quit and a new thread will be created when new work is scheduled. + + + + + Gate to protect data structures, including the work queue and the ready list. + + + + + Semaphore to count requests to re-evaluate the queue, from either Schedule requests or when a timer + expires and moves on to the next item in the queue. + + + + + Queue holding work items. Protected by the gate. + + + + + Queue holding items that are ready to be run as soon as possible. Protected by the gate. + + + + + Work item that will be scheduled next. Used upon reevaluation of the queue to check whether the next + item is still the same. If not, a new timer needs to be started (see below). + + + + + Disposable that always holds the timer to dispatch the first element in the queue. + + + + + Flag indicating whether the event loop should quit. When set, the event should be signaled as well to + wake up the event loop thread, which will subsequently abandon all work. + + + + + Creates an object that schedules units of work on a designated thread. + + + + + Creates an object that schedules units of work on a designated thread, using the specified factory to control thread creation options. + + Factory function for thread creation. + is null. + + + + Schedules an action to be executed after dueTime. + + 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. + The scheduler has been disposed and doesn't accept new work. + + + + Schedules a periodic piece of work on the designated thread. + + 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 TimeSpan.Zero. + The scheduler has been disposed and doesn't accept new work. + + + + Ends the thread associated with this scheduler. All remaining work in the scheduler queue is abandoned. + + + + + Ensures there is an event loop thread running. Should be called under the gate. + + + + + Event loop scheduled on the designated event loop thread. The loop is suspended/resumed using the event + which gets set by calls to Schedule, the next item timer, or calls to Dispose. + + + + + Indicates whether the event loop thread is allowed to quit when no work is left. If new work + is scheduled afterwards, a new event loop thread is created. This property is used by the + NewThreadScheduler which uses an event loop for its recursive invocations. + + + + + Represents an object that schedules each unit of work on a separate thread. + + + + + Creates an object that schedules each unit of work on a separate thread. + + + + + Creates an object that schedules each unit of work on a separate thread. + + Factory function for thread creation. + is null. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Schedules a long-running task by creating a new thread. Cancellation happens through polling. + + 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. + + + + Schedules a periodic piece of work by creating a new thread that goes to sleep when work has been dispatched and wakes up again at the next periodic due time. + + 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 TimeSpan.Zero. + + + + Gets an instance of this scheduler that uses the default Thread constructor. + + + + + Provides access to the platform enlightenments used by other Rx libraries to improve system performance and + runtime efficiency. While Rx can run without platform enlightenments loaded, it's recommended to deploy the + System.Reactive.PlatformServices assembly with your application and call during application startup to ensure enlightenments are properly loaded. + + + + + Ensures that the calling assembly has a reference to the System.Reactive.PlatformServices assembly with + platform enlightenments. If no reference is made from the user code, it's possible for the build process + to drop the deployment of System.Reactive.PlatformServices, preventing its runtime discovery. + + + true if the loaded enlightenment provider matches the provided defined in the current assembly; false + otherwise. When a custom enlightenment provider is installed by the host, false will be returned. + + + + + Represents an object that schedules units of work on the Task Parallel Library (TPL) task pool. + + Instance of this type using the default TaskScheduler to schedule work on the TPL task pool. + + + + Creates an object that schedules units of work using the provided TaskFactory. + + Task factory used to create tasks to run units of work. + is null. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Schedules a long-running task by creating a new task using TaskCreationOptions.LongRunning. Cancellation happens through polling. + + 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. + + + + Schedules a periodic piece of work by running a platform-specific timer to create tasks periodically. + + 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 TimeSpan.Zero. + + + + Gets an instance of this scheduler that uses the default TaskScheduler. + + + + + Represents an object that schedules units of work on the CLR thread pool. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a System.Threading.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. + + + + Schedules a long-running task by creating a new thread. Cancellation happens through polling. + + 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. + + + + Schedules a periodic piece of work, using a System.Threading.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 or equal to zero. + + + + Gets the singleton instance of the CLR thread pool scheduler. + + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to The WinRT thread pool doesn't support creating periodic timers with a period below 1 millisecond.. + + + + diff --git a/packages/Rx-PlatformServices.2.1.30214.0/lib/SL5/System.Reactive.PlatformServices.dll b/packages/Rx-PlatformServices.2.1.30214.0/lib/SL5/System.Reactive.PlatformServices.dll new file mode 100644 index 0000000000000000000000000000000000000000..a622c43e2526035258572e6272fef375328808bc GIT binary patch literal 37984 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 + Represents an object that schedules units of work on a designated thread. + + + + + Counter for diagnostic purposes, to name the threads. + + + + + Thread factory function. + + + + + Stopwatch for timing free of absolute time dependencies. + + + + + Thread used by the event loop to run work items on. No work should be run on any other thread. + If ExitIfEmpty is set, the thread can quit and a new thread will be created when new work is scheduled. + + + + + Gate to protect data structures, including the work queue and the ready list. + + + + + Semaphore to count requests to re-evaluate the queue, from either Schedule requests or when a timer + expires and moves on to the next item in the queue. + + + + + Queue holding work items. Protected by the gate. + + + + + Queue holding items that are ready to be run as soon as possible. Protected by the gate. + + + + + Work item that will be scheduled next. Used upon reevaluation of the queue to check whether the next + item is still the same. If not, a new timer needs to be started (see below). + + + + + Disposable that always holds the timer to dispatch the first element in the queue. + + + + + Flag indicating whether the event loop should quit. When set, the event should be signaled as well to + wake up the event loop thread, which will subsequently abandon all work. + + + + + Creates an object that schedules units of work on a designated thread. + + + + + Creates an object that schedules units of work on a designated thread, using the specified factory to control thread creation options. + + Factory function for thread creation. + is null. + + + + Schedules an action to be executed after dueTime. + + 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. + The scheduler has been disposed and doesn't accept new work. + + + + Schedules a periodic piece of work on the designated thread. + + 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 TimeSpan.Zero. + The scheduler has been disposed and doesn't accept new work. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Ends the thread associated with this scheduler. All remaining work in the scheduler queue is abandoned. + + + + + Ensures there is an event loop thread running. Should be called under the gate. + + + + + Event loop scheduled on the designated event loop thread. The loop is suspended/resumed using the event + which gets set by calls to Schedule, the next item timer, or calls to Dispose. + + + + + Indicates whether the event loop thread is allowed to quit when no work is left. If new work + is scheduled afterwards, a new event loop thread is created. This property is used by the + NewThreadScheduler which uses an event loop for its recursive invocations. + + + + + Represents an object that schedules each unit of work on a separate thread. + + + + + Creates an object that schedules each unit of work on a separate thread. + + + + + Creates an object that schedules each unit of work on a separate thread. + + Factory function for thread creation. + is null. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Schedules a long-running task by creating a new thread. Cancellation happens through polling. + + 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. + + + + Schedules a periodic piece of work by creating a new thread that goes to sleep when work has been dispatched and wakes up again at the next periodic due time. + + 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 TimeSpan.Zero. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Gets an instance of this scheduler that uses the default Thread constructor. + + + + + Provides access to the platform enlightenments used by other Rx libraries to improve system performance and + runtime efficiency. While Rx can run without platform enlightenments loaded, it's recommended to deploy the + System.Reactive.PlatformServices assembly with your application and call during application startup to ensure enlightenments are properly loaded. + + + + + Ensures that the calling assembly has a reference to the System.Reactive.PlatformServices assembly with + platform enlightenments. If no reference is made from the user code, it's possible for the build process + to drop the deployment of System.Reactive.PlatformServices, preventing its runtime discovery. + + + true if the loaded enlightenment provider matches the provided defined in the current assembly; false + otherwise. When a custom enlightenment provider is installed by the host, false will be returned. + + + + + Represents an object that schedules units of work on the Task Parallel Library (TPL) task pool. + + Instance of this type using the default TaskScheduler to schedule work on the TPL task pool. + + + + Creates an object that schedules units of work using the provided TaskFactory. + + Task factory used to create tasks to run units of work. + is null. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime. + + 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. + + + + Schedules a long-running task by creating a new task using TaskCreationOptions.LongRunning. Cancellation happens through polling. + + 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. + + + + Gets a new stopwatch ob ject. + + New stopwatch object; started at the time of the request. + + + + Schedules a periodic piece of work by running a platform-specific timer to create tasks periodically. + + 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 TimeSpan.Zero. + + + + Gets an instance of this scheduler that uses the default TaskScheduler. + + + + + Represents an object that schedules units of work on the CLR thread pool. + + Singleton instance of this type exposed through this static property. + + + + Schedules an action to be executed. + + 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. + + + + Schedules an action to be executed after dueTime, using a System.Threading.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. + + + + Schedules a long-running task by creating a new thread. Cancellation happens through polling. + + 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. + + + + Starts a new stopwatch object. + + New stopwatch object; started at the time of the request. + + + + Schedules a periodic piece of work, using a System.Threading.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 or equal to zero. + + + + Gets the singleton instance of the CLR thread pool scheduler. + + + + + (Infrastructure) Provider for platform-specific framework enlightenments. + + + + + (Infastructure) Tries to gets the specified service. + + Service type. + Optional set of arguments. + Service instance or null if not found. + + + + A strongly-typed resource class, for looking up localized strings, etc. + + + + + Returns the cached ResourceManager instance used by this class. + + + + + Overrides the current thread's CurrentUICulture property for all + resource lookups using this strongly typed resource class. + + + + + Looks up a localized string similar to The WinRT thread pool doesn't support creating periodic timers with a period below 1 millisecond.. + + + + diff --git a/packages/Rx-PlatformServices.2.1.30214.0/lib/WP8/System.Reactive.PlatformServices.dll b/packages/Rx-PlatformServices.2.1.30214.0/lib/WP8/System.Reactive.PlatformServices.dll new file mode 100644 index 0000000000000000000000000000000000000000..651e148c5a5e46deae76a3b9464f6b68cc16443b GIT binary patch literal 37976 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

            gm>A)O@x+@_nCKnJZqU`W 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≶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%0Dk4olF)*+M3eGq@Dqgn#qu68DR%s8T?HgSC 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 literal 0 HcmV?d00001 diff --git a/packages/Rx-PlatformServices.2.1.30214.0/lib/WP8/System.Reactive.PlatformServices.XML b/packages/Rx-PlatformServices.2.1.30214.0/lib/WP8/System.Reactive.PlatformServices.XML new file mode 100644 index 000000000..fcb42c0c5 --- /dev/null +++ b/packages/Rx-PlatformServices.2.1.30214.0/lib/WP8/System.Reactive.PlatformServices.XML @@ -0,0 +1,378 @@ + + + + System.Reactive.PlatformServices + + + +

^wIK=`S| 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 z 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