From 5f831de0bc70bc660d21c3b9e04e581269691a2a Mon Sep 17 00:00:00 2001 From: Ian Griffiths Date: Fri, 5 Jul 2024 09:20:44 +0100 Subject: [PATCH] Update Ix.NET for .NET 8.0 sdk (#2135) * Make Ix homoiconicity generator nullable-aware * Upgrade ApiCompare and Playground to .NET 8.0 * Fix diagnostics * Removed old NO_ARRAY_EMPTY conditional sections as no build targets now set that * Add .NET 8.0 targets for test projects * Add readme explaining use of .NET Core 3.1 in tests * Remove use of MSBuild.Sdk.Extras and step to build refs explicitly * Replace erroneous net4.8 TFM with net48 in reference assemblies --- .editorconfig | 4 + .../adr/0001-Ix-Ref-Assembly-Mismatches.md | 106 +++ Ix.NET/Source/.editorconfig | 34 + Ix.NET/Source/ApiCompare/ApiCompare.csproj | 2 +- Ix.NET/Source/ApiCompare/Program.cs | 204 +++-- Ix.NET/Source/AsyncQueryableGenerator.t4 | 79 +- Ix.NET/Source/Directory.Build.props | 6 +- Ix.NET/Source/FasterLinq/FasterLinq.csproj | 2 + Ix.NET/Source/FasterLinq/Program.cs | 11 +- Ix.NET/Source/Ix.NET.sln | 28 +- Ix.NET/Source/NetCore31TestReadme.txt | 7 + Ix.NET/Source/Playground/DemoAttribute.cs | 12 +- Ix.NET/Source/Playground/Playground.csproj | 2 +- Ix.NET/Source/Playground/Program.cs | 28 +- ...m.Interactive.Async.Providers.Tests.csproj | 3 +- .../System.Interactive.Async.Providers.csproj | 4 + .../System/Linq/AsyncQueryableEx.Generated.cs | 142 ++-- .../System/Linq/AsyncQueryableEx.Generated.tt | 8 +- .../System.Interactive.Async.Tests.csproj | 11 +- .../System/Linq/Operators/Buffer.cs | 16 +- .../System/Linq/Operators/MaxBy.cs | 4 +- .../System/Linq/Operators/MinBy.cs | 4 +- .../System/Linq/Operators/Never.cs | 4 + .../System.Interactive.Async/EmptyArray.cs | 15 - .../System.Interactive.Async.csproj | 5 + .../System/Linq/Operators/Generate.cs | 2 +- .../System/Linq/Operators/Merge.cs | 31 +- .../System/Linq/Operators/MinBy.cs | 6 +- .../System/Linq/Operators/Never.cs | 10 +- .../System/Linq/Operators/Return.cs | 6 +- .../System/Linq/Operators/Timeout.cs | 6 + .../System.Interactive.Providers.csproj | 29 +- .../System/Linq/QueryableEx.cs | 4 +- .../System.Interactive.Tests.csproj | 10 +- .../System/Linq/Operators/Buffer.cs | 34 +- .../System/Linq/Operators/Case.cs | 6 +- .../System/Linq/Operators/Create.cs | 2 +- .../System/Linq/Operators/Distinct.cs | 8 +- .../Linq/Operators/DistinctUntilChanged.cs | 12 +- .../System/Linq/Operators/Do.cs | 18 +- .../System/Linq/Operators/DoWhile.cs | 6 +- .../System/Linq/Operators/Expand.cs | 6 +- .../System/Linq/Operators/Finally.cs | 2 +- .../System/Linq/Operators/For.cs | 6 +- .../System/Linq/Operators/ForEach.cs | 4 +- .../System/Linq/Operators/Generate.cs | 2 +- .../System/Linq/Operators/If.cs | 10 +- .../System/Linq/Operators/MaxBy.cs | 8 +- .../System/Linq/Operators/Memoize.cs | 18 +- .../System/Linq/Operators/MinBy.cs | 8 +- .../Linq/Operators/OnErrorResumeNext.cs | 18 +- .../System/Linq/Operators/Publish.cs | 6 +- .../System/Linq/Operators/Repeat.cs | 2 +- .../System/Linq/Operators/Retry.cs | 2 +- .../System/Linq/Operators/Scan.cs | 8 +- .../System/Linq/Operators/SelectMany.cs | 6 +- .../System/Linq/Operators/Share.cs | 6 +- .../System/Linq/Operators/SkipLast.cs | 2 +- .../System/Linq/Operators/TakeLast.cs | 4 +- .../System/Linq/Operators/Using.cs | 2 +- .../System/Linq/Operators/While.cs | 6 +- .../Source/System.Interactive.Tests/Tests.cs | 2 - .../System.Interactive.csproj | 29 +- .../System/Linq/MaxRefCountList.cs | 2 +- .../System/Linq/Operators/Case.cs | 2 +- .../System/Linq/Operators/Create.cs | 8 +- .../System/Linq/Operators/If.cs | 2 +- .../System/Linq/Operators/MaxByWithTies.cs | 2 +- .../System/Linq/Operators/Memoize.cs | 5 +- .../System/Linq/Operators/Publish.cs | 2 +- .../System/Linq/Operators/Share.cs | 9 +- .../System/Linq/Operators/SkipLast.cs | 2 +- .../System/Linq/Operators/TakeLast.cs | 2 +- .../System/Linq/Operators/Throw.cs | 4 +- .../System/Linq/RefCountList.cs | 12 +- .../System.Linq.Async.Queryable.Tests.csproj | 3 +- .../System.Linq.Async.Queryable.csproj | 5 + .../System/Linq/AsyncEnumerableQuery.cs | 2 +- .../System/Linq/AsyncEnumerableRewriter.cs | 9 +- .../System/Linq/AsyncQueryable.Generated.cs | 758 +++++++++--------- .../System/Linq/AsyncQueryable.Generated.tt | 6 +- .../System/Linq/AsyncQueryable.cs | 16 - .../System.Linq.Async.Tests.csproj | 11 +- .../System/Linq/Operators/Aggregate.cs | 18 +- .../System/Linq/Operators/Any.cs | 2 +- .../System/Linq/Operators/Count.cs | 8 +- .../System/Linq/Operators/First.cs | 4 +- .../System/Linq/Operators/FirstOrDefault.cs | 4 +- .../System/Linq/Operators/GroupBy.cs | 6 +- .../System/Linq/Operators/GroupJoin.cs | 4 + .../System/Linq/Operators/Join.cs | 38 +- .../System/Linq/Operators/Last.cs | 4 +- .../System/Linq/Operators/LastOrDefault.cs | 4 +- .../System/Linq/Operators/LongCount.cs | 8 +- .../System/Linq/Operators/Max.cs | 6 +- .../System/Linq/Operators/Min.cs | 6 +- .../System/Linq/Operators/Range.cs | 2 +- .../System/Linq/Operators/Reverse.cs | 4 +- .../System/Linq/Operators/Select.cs | 128 +-- .../System/Linq/Operators/Single.cs | 2 +- .../System/Linq/Operators/SingleOrDefault.cs | 2 +- .../System/Linq/Operators/Skip.cs | 16 +- .../System/Linq/Operators/Take.cs | 16 +- .../System/Linq/Operators/ToArray.cs | 2 +- .../Linq/Operators/ToAsyncEnumerable.cs | 12 +- .../System/Linq/Operators/ToEnumerable.cs | 4 +- .../System/Linq/Operators/ToHashSet.cs | 4 +- .../System/Linq/Operators/ToLookup.cs | 2 - .../System/Linq/Operators/ToObservable.cs | 6 +- .../System/Linq/Operators/Union.cs | 8 +- Ix.NET/Source/System.Linq.Async.slnf | 2 +- .../System.Linq.Async.csproj | 34 +- .../System/Linq/AsyncEnumerableHelpers.cs | 6 +- .../System/Linq/AsyncEnumerablePartition.cs | 10 +- .../System/Linq/AsyncListPartition.cs | 10 +- .../System/Linq/Disposables.cs | 2 +- .../System/Linq/Operators/AppendPrepend.cs | 4 +- .../System/Linq/Operators/DefaultIfEmpty.cs | 2 +- .../System/Linq/Operators/Empty.cs | 22 +- .../System/Linq/Operators/Grouping.cs | 2 + .../System/Linq/Operators/Lookup.cs | 8 - .../Linq/Operators/OrderedAsyncEnumerable.cs | 28 +- .../System/Linq/Operators/Range.cs | 6 +- .../System/Linq/Operators/Repeat.cs | 2 +- .../System/Linq/Operators/Reverse.cs | 6 +- .../System/Linq/Operators/SingleLinkedNode.cs | 2 +- .../Operators/ToAsyncEnumerable.Observable.cs | 2 +- .../System/Linq/Operators/ToObservable.cs | 48 +- .../System/Linq/Operators/Union.cs | 2 + .../System.Linq.Async/System/Linq/Set.cs | 2 + .../Threading/Tasks/AsyncEnumerableExt.cs | 6 + ...pprovalTests.SystemInteractive.verified.cs | 104 +++ ...alTests.SystemInteractiveAsync.verified.cs | 108 +++ ...ystemInteractiveAsyncProviders.verified.cs | 82 ++ ...sts.SystemInteractiveProviders.verified.cs | 147 ++++ ...iApprovalTests.SystemLinqAsync.verified.cs | 436 ++++++++++ ...Tests.SystemLinqAsyncQueryable.verified.cs | 413 ++++++++++ .../Api/ApiApprovalTests.cs | 95 +++ .../DiffPlexReporter.cs | 38 + ...sts.System.Interactive.ApiApprovals.csproj | 43 + Ix.NET/Source/global.json | 5 - .../System.Interactive.Providers.csproj | 14 +- .../System.Interactive.csproj | 12 +- .../System.Linq.Async.csproj | 27 - .../System.Linq.Async.csproj | 35 + azure-pipelines.ix.yml | 10 + 146 files changed, 2902 insertions(+), 1143 deletions(-) create mode 100644 Ix.NET/Documentation/adr/0001-Ix-Ref-Assembly-Mismatches.md create mode 100644 Ix.NET/Source/.editorconfig create mode 100644 Ix.NET/Source/NetCore31TestReadme.txt delete mode 100644 Ix.NET/Source/System.Interactive.Async/EmptyArray.cs create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractive.verified.cs create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.verified.cs create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.verified.cs create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveProviders.verified.cs create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.verified.cs create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.verified.cs create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.cs create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/DiffPlexReporter.cs create mode 100644 Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Tests.System.Interactive.ApiApprovals.csproj delete mode 100644 Ix.NET/Source/global.json rename Ix.NET/Source/refs/{System.Interactive.Providers.Ref => System.Interactive.Providers}/System.Interactive.Providers.csproj (55%) rename Ix.NET/Source/refs/{System.Interactive.Ref => System.Interactive}/System.Interactive.csproj (58%) delete mode 100644 Ix.NET/Source/refs/System.Linq.Async.Ref/System.Linq.Async.csproj create mode 100644 Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj diff --git a/.editorconfig b/.editorconfig index ea4c9aff7e..95b58d8c7e 100644 --- a/.editorconfig +++ b/.editorconfig @@ -252,3 +252,7 @@ csharp_space_between_method_declaration_name_and_open_parenthesis = false csharp_space_between_method_declaration_parameter_list_parentheses = false csharp_space_between_parentheses = false csharp_space_between_square_brackets = false + +# Primary constructors +# We find these something of a mixed bag. +dotnet_diagnostic.IDE0290.severity = none \ No newline at end of file diff --git a/Ix.NET/Documentation/adr/0001-Ix-Ref-Assembly-Mismatches.md b/Ix.NET/Documentation/adr/0001-Ix-Ref-Assembly-Mismatches.md new file mode 100644 index 0000000000..a28c0329dc --- /dev/null +++ b/Ix.NET/Documentation/adr/0001-Ix-Ref-Assembly-Mismatches.md @@ -0,0 +1,106 @@ +# Apparent mismatches between lib and ref in the `System.Interactive` NuGet package + +The `System.Interactive` NuGet package contains the usual `lib` folder, and also `ref`, the standard folder for reference assemblies. But the set of target frameworks in these two folders is, rather unusually, different. This document explains why. + +## Status + +Fait acomplis. + +This dates back at least as far as 2018. The main purpose of this document (written in 2024) is to explain why it's like it is. The original thinking was lost in the mists of time, and it took considerable effort to work out why on earth it's like this. This ADR is intended to save others from the same extensive archaeology. And the discovery is important: if we hadn't managed to reverse engineer the apparent thinking behind this design choice, we might have dismissed it as a mistake. (Indeed, part of its current implementation _is_ a mistake.) But it turns out to serve an important purpose in a non-obvious way. + + +## Authors + +@idg10 ([Ian Griffiths](https://endjin.com/who-we-are/our-people/ian-griffiths/)) wrote this document, but he would like to make it clear that he did not make the original design decision in question. He is merely documenting it. + + +## Context + +At the time of writing this, the current version of `System.Interactive` is 6.0.1. If you inspect the NuGet package you will find that the lib and ref folders have different sets of frameworks: + +* `lib` + * `net6.0` + * `net48` + * `netstandard2.0` +* `ref` + * `net4.8` + * `net6.0` + * `netstandard2.1` + + +The use of `net4.8` in `ref` seems to have been a bug: that should have been `net48`. (The main reason I am confident it's a bug, and not a clever but obscure trick that we've not understood, is that the [commit of 2021/12/06 that added this](https://github.com/dotnet/reactive/commit/a2410b2267abe193191f3894d243771ae4b126fd) used [`net48` in reference assemblies for one of the other packages](https://github.com/dotnet/reactive/commit/a2410b2267abe193191f3894d243771ae4b126fd#diff-3b568c93a468dab1b1a619a450bf1c4d88d3ec9539737d09fa6fb7659bc0ae5fR7), so this just seems to have been a slip.) + +The other discrepancy is that we have `netstandard2.0` in the `lib` folder but `netstandard2.1` in the ref folder. At first glance, this too looks quite a lot like a mistake, particularly when you examine the history. Here is the point in the release history at which the `ref` folder first started having a `netstandard2.1` folder: + +* v3.1.1: + * no reference assemblies + * folder supports .NET FX 4.5 and .NET Standard 1.0 +* v3.2.0 + * reference assemblies for netcoreapp2.0, netstandard1.0, and netstandard2.1 + * lib folder supports .NET FX 4.5 and .NET Standard 1.0, and .NET Standard 2.1 + +When v3.2.0 shipped in July 2018, the latest .NET Core was 2.1, which had shipped in May 2018. .NET Standard 2.1 was not yet a thing, because that didn't appear until November 2018, when the oldest .NET to support it (.NET Core 3.0) shipped. So on a first inspection, Ix.NET declared reference assemblies for a target framework that simply didn't exist! + +And yet, on closer inspection, this appears to be deliberate. Looking at this commit: + + https://github.com/dotnet/reactive/commit/0252fb537c9d335b9bc863b65291f152c07ba385 + + we see a [comment in Ix.NET/Source/refs/Directory.build.props](https://github.com/dotnet/reactive/commit/0252fb537c9d335b9bc863b65291f152c07ba385#diff-909504334cbab5c432709c95ae78c24fb2910d850958af2ef6de444b18e5c8ecR6) saying: + +> This is here so we can create a fake .NET Standard 2.1 facade + +I can only guess that they knew .NET Standard 2.1 was coming, and wanted to ensure that `System.Interactive` was ready for it when it shipped. + +So it was deliberate. But offering reference assemblies for a platform without any corresponding implementation for that platform is an odd choice. (And although at the time this was a placholder for a forthcoming .NET Standard version, it continued to look like this after .NET Standard 2.1 shipped. All subsequent Ix.NET releases have continued to provide `netstandard2.1` in the `ref` folder with no matching folder in `lib`. So it wasn't just a temporary measure.) What purpose does this serve? + +Some of the features that Ix offers eventually became available in .NET Core, such as `EnumerableEx.SkipLast`. This method exists in the implementation assemblies for every TFM of Ix.NET, but the `netstandard2.1` and `net6.0` reference assemblies omit it. This has the effect that if you're targetting any version of .NET recent enough to have these methods built into the .NET runtime libraries, the Ix.NET equivalents will: + +* appear not to exist at build time +* still be available at runtime + +The non-availability at build time is important because these are extension methods. If multiple extension methods of the same name and for same type are available in the same namespace, you get compiler errors when you try to use them in the normal way. (E.g., .NET defines `System.Linq.Enumerable.SkipLast` and Ix.NET defines `System.Linq.EnumerableEx.SkipLast`, and both are defined as extension methods for `IEnumerable`. If it weren't for this NuGet package trickery, any file that has `using System.Linq;` would bring both the Ix and .NET versions into scope, with no straightforward way to indicate which one you want. You can resolve this with some quite obscure use of `extern` aliases, but it's not at all obvious how. If anyone using `System.Interactive` had run into this the moment they upgraded to .NET Core 3.1, that would have been a bad experience.) + +By arranging for the `netstandard2.1` and `net6.0` reference assemblies to omit these methods, Ix.NET ensures that the C# compiler has no idea these methods even exist, avoiding the problem. But why do we need reference assemblies for this? Why not just omit the methods from the main assemblies? That's because you might depend on some library, `OldLib`, that was built for `netstandard2.0`, where, say, `SkipLast` is unavailable. `OldLib` might use Ix.NET's `EnumerableEx.SkipLast`, so that method really has to be there at runtime, even if you're running on, say, .NET 8.0. .NET 8.0 provides `Enumerable.SkipLast` but if `OldLib` is only available in `netstandard2.0` form it won't have access to that. It can only use the `Ix.NET` one. So that method has to be there at runtime. + +So the basic trick here is that Ix.NET provides one API surface area for backwards compatibility purposes and a slightly smaller API surface that it advertises to new code targeting the latest Ix.NET. The `lib` folder contains complete assemblies providing the former, and the `ref` folder contains reference assemblies providing the latter. + +This still doesn't make it obvious why it's useful for `ref` to include `netstandard2.1` when `lib` does not. If I've understood the original design here, the thinking is that on any runtime where `netstandard2.1` is available, methods like `Enumerable.SkipLast` are available in the runtime libraries, so libraries built for `netstandard2.1` should be using that built-in `Enumerable.SkipLast`, and not Ix.NET's `EnumerableEx.SkipLast`. At runtime, `netstandard2.1` libraries with a dependency on `System.Interactive` may well find themselves using the `lib\netstandard2.0` version (because there is no `lib\netstandard2.1` version). E.g.: + +| `MyLib` TFM | Ix Ref Assembly TFM (for `MyLib` build) | Runtime | Ix Lib Assembly TFM | `SkipLast` used by `MyLib` +|--|--|--|--|--| +| `netstandard2.0` | `netstandard2.0` | .NET Core 2.1 | `netstandard2.0` | Ix | +| `netstandard2.0` | `netstandard2.0` | .NET 6.0 | `net6.0` | Ix | +| `netstandard2.0` | `netstandard2.0` | .NET Framework | `net48` | Ix | +| `netstandard2.1` | `netstandard2.1` | Mono | `netstandard2.0` | .NET Runtime Libraries | +| `netstandard2.1` | `netstandard2.1` | Unity | `netstandard2.0` | .NET Runtime Libraries | +| `netstandard2.1` | `netstandard2.1` | .NET Core 3.1 | `netstandard2.0` (Ix.NET 6.0.1 has no .NET Core 3.1 version so this is the only available option) | .NET Runtime Libraries | +| `netstandard2.1` | `netstandard2.1` | .NET 6.0 | `net6.0` | .NET Runtime Libraries | +| `netcore3.1` | `netstandard2.1` | .NET Core 3.1 | `netstandard2.0` | .NET Runtime Libraries | +| `netcore3.1` | `netstandard2.1` | .NET 6.0 | `net6.0` | .NET Runtime Libraries | +| `net48` | `net48`* | .NET 4.8 | `net48` | Ix | +| `net6.0` | `net6.0` | .NET 6.0 | `net6.0` | .NET Runtime Libraries | + +\* although this table represents the design intent, the fact that the reference assemblies were accidentally given the non-existent TFM `net4.8` instead of `net48` means that things didn't work out as described in that row in practice. That mistake meant that for that row, it instead looked like this: + +| `MyLib` TFM | Ix Ref Assembly TFM (for `MyLib` build) | Runtime | Ix Lib Assembly TFM | `SkipLast` used by `MyLib` +|--|--|--|--|--| +| `net48` | `netstandard2.0` (oops) | .NET 4.8 | `net48` | Ix | + +The reason this went undetected is that it happened to produce the required outcome: the library uses Ix's `SkipLast`, which is what we need here because .NET 4.8 doesn't have that. + +The most interesting row of the first table is the second one: it's the one case where the Ix implementation is used even though the runtime (.NET 6.0) does offer `SkipLast`. It works out this way because the library is built against `netstandard2.0`, so that runtime-supplied `SkipLast` simply isn't part of the available surface area (and in the other two rows where the library was built against `netstandard2.0`, it's not just absent from the compile-time surface area on those rows, it's also absent at runtime, which is exactly why `netstandard2.0` library can't use it). This has to work: any library compiled in a world where the runtime doesn't offer `Enumerable.SkipLast`, and which chose to use Ix's `EnumerableEx.SkipLast`, must continue to work even if loaded into a newer runtime that does offer `Enumerable.SkipLast`. .NET does not provide any method-level equivalent of type forwarding, so there's no way to arrange for the library to get the runtime's `Enumerable.SkipLast` in these situations, so it just has to use the Ix.NET one. That's why when Ix.NET is loaded onto runtimes that offer `Enumerable.SkipLast`, it's necessary for it still to make `EnumerableEx.SkipLast` available in case there are libraries that need it. But it also needs to ensure that this API appears not to exist for any code compiling against a target where `Enumerable.SkipLast` will be available. + + +## Decision + +We will continue to use the same technique, although with two changes: + +* we will fix the `net4.8`/`net48` bug +* we will no longer use `MSBuild.Extras.SDK` + +This somewhat unusual mismatched `lib` vs `ref` folder setup was previously handled by `MSBuild.Extras.SDK`, but that package is no longer maintained. (It hasn't been updated since .NET 5.0 was the latest runtime.) When we moved to the 8.0 SDK, the reference assembly generation stopped working, so we've had to recreate the same result by supported means. (That is what necessitated the git archaeological dig that led to the writing of this document.) + + +## Consequences + +By continuing the established practice, Ix.NET's `SkipLast` will continue to be available to library authors targeting `netstandard2.0`, and its presence will continue not to cause hard to resolve ambiguous method errors when using newer TFMs. By droping `MSBuild.Extras.SDK`, we'll be able to get things building again on .NET SDK 8.0. Future maintainers will likely continue to be confused by the mismatched `lib` and `ref` folders when they first come across it, but we're hopeful that the existence of this ADR will help. \ No newline at end of file diff --git a/Ix.NET/Source/.editorconfig b/Ix.NET/Source/.editorconfig new file mode 100644 index 0000000000..5dc8f891f8 --- /dev/null +++ b/Ix.NET/Source/.editorconfig @@ -0,0 +1,34 @@ +[*.cs] + +# Prevent IDE1006 (Naming rule violation) errors for non-public fields. +# +# Unfortunately, the codebase has not historically been entirely consistent with internal naming +# conventions. Apparently this wasn't noticed by older analyzer tooling, but as of the .NET 7 +# era, the naming rules analyzers are a bit more particular, and cannot be configured in a way +# that makes them happy with the code as it stands. We could rename all the relevant symbols, +# but that doesn't seem like an especially good use of time, so for now, we're suppressing +# diagnostics in certain cases. +# +# Static readonly fields +#dotnet_naming_rule.static_readonly_fields_should_be_pascal_case.severity = none + +# Internal fields +dotnet_naming_symbols.internal_field_symbols.applicable_kinds = field +dotnet_naming_symbols.internal_field_symbols.applicable_accessibilities = internal + +dotnet_naming_rule.internal_instance_fields_must_be_camel_cased_underscore_prefix.symbols = internal_field_symbols +dotnet_naming_rule.internal_instance_fields_must_be_camel_cased_underscore_prefix.style = camel_case_and_prefix_with_underscore_style +#dotnet_naming_rule.internal_instance_fields_must_be_camel_cased_underscore_prefix.severity = none + + +# Protected fields +# Annoyingly, a protected field in an internal class cannot be distinguished from a protected field in a public +# class. That's unfortunate, because the latter are publicly visible, but the former are not, so we don't really +# want to enforce public naming conventions on them. We generally avoid publicly visible fields, so the majority +# of protected fields are in fact in internal types, so we use naming conventions appropriate to those. +dotnet_naming_symbols.protected_field_symbols.applicable_kinds = field +dotnet_naming_symbols.protected_field_symbols.applicable_accessibilities = protected + +dotnet_naming_rule.protected_instance_fields_must_be_camel_cased_underscore_prefix.symbols = protected_field_symbols +dotnet_naming_rule.protected_instance_fields_must_be_camel_cased_underscore_prefix.style = camel_case_and_prefix_with_underscore_style +dotnet_naming_rule.protected_instance_fields_must_be_camel_cased_underscore_prefix.severity = none diff --git a/Ix.NET/Source/ApiCompare/ApiCompare.csproj b/Ix.NET/Source/ApiCompare/ApiCompare.csproj index 495d7d0ead..174cbcc1fd 100644 --- a/Ix.NET/Source/ApiCompare/ApiCompare.csproj +++ b/Ix.NET/Source/ApiCompare/ApiCompare.csproj @@ -2,7 +2,7 @@ Exe - net6.0 + net8.0 diff --git a/Ix.NET/Source/ApiCompare/Program.cs b/Ix.NET/Source/ApiCompare/Program.cs index 7efcf095a7..f1fd575979 100644 --- a/Ix.NET/Source/ApiCompare/Program.cs +++ b/Ix.NET/Source/ApiCompare/Program.cs @@ -13,16 +13,16 @@ namespace ApiCompare { - class Program + internal class Program { - private static readonly Type asyncInterfaceType = typeof(IAsyncEnumerable<>); - private static readonly Type syncInterfaceType = typeof(IEnumerable<>); + private static readonly Type AsyncInterfaceType = typeof(IAsyncEnumerable<>); + private static readonly Type SyncInterfaceType = typeof(IEnumerable<>); - private static readonly Type asyncOrderedInterfaceType = typeof(IOrderedAsyncEnumerable<>); - private static readonly Type syncOrderedInterfaceType = typeof(IOrderedEnumerable<>); + private static readonly Type AsyncOrderedInterfaceType = typeof(IOrderedAsyncEnumerable<>); + private static readonly Type SyncOrderedInterfaceType = typeof(IOrderedEnumerable<>); - private static readonly string[] exceptions = new[] - { + private static readonly string[] Exceptions = + [ "SkipLast", // In .NET Core 2.0 "TakeLast", // In .NET Core 2.0 @@ -39,16 +39,16 @@ class Program "ToAsyncEnumerable", // First-class conversions "ToEnumerable", // First-class conversions "ToObservable", // First-class conversions - }; + ]; - private static readonly TypeSubstitutor subst = new TypeSubstitutor(new Dictionary + private static readonly TypeSubstitutor Subst = new(new Dictionary { - { asyncInterfaceType, syncInterfaceType }, - { asyncOrderedInterfaceType, syncOrderedInterfaceType }, + { AsyncInterfaceType, SyncInterfaceType }, + { AsyncOrderedInterfaceType, SyncOrderedInterfaceType }, { typeof(IAsyncGrouping<,>), typeof(IGrouping<,>) }, }); - static void Main() + private static void Main() { var asyncOperatorsType = typeof(AsyncEnumerable); var syncOperatorsType = typeof(Enumerable); @@ -56,22 +56,22 @@ static void Main() Compare(syncOperatorsType, asyncOperatorsType); } - static void Compare(Type syncOperatorsType, Type asyncOperatorsType) + private static void Compare(Type syncOperatorsType, Type asyncOperatorsType) { - var syncOperators = GetQueryOperators(new[] { syncInterfaceType, syncOrderedInterfaceType }, syncOperatorsType, exceptions); - var asyncOperators = GetQueryOperators(new[] { asyncInterfaceType, asyncOrderedInterfaceType }, asyncOperatorsType, exceptions); + var syncOperators = GetQueryOperators([SyncInterfaceType, SyncOrderedInterfaceType], syncOperatorsType, Exceptions); + var asyncOperators = GetQueryOperators([AsyncInterfaceType, AsyncOrderedInterfaceType], asyncOperatorsType, Exceptions); CompareFactories(syncOperators.Factories, asyncOperators.Factories); CompareQueryOperators(syncOperators.QueryOperators, asyncOperators.QueryOperators); CompareAggregates(syncOperators.Aggregates, asyncOperators.Aggregates); } - static void CompareFactories(ILookup syncFactories, ILookup asyncFactories) + private static void CompareFactories(ILookup syncFactories, ILookup asyncFactories) { CompareSets(syncFactories, asyncFactories, CompareFactoryOverloads); } - static void CompareFactoryOverloads(string name, IEnumerable syncMethods, IEnumerable asyncMethods) + private static void CompareFactoryOverloads(string name, IEnumerable syncMethods, IEnumerable asyncMethods) { var sync = GetSignatures(syncMethods).ToArray(); var async = GetRewrittenSignatures(asyncMethods).ToArray(); @@ -105,12 +105,12 @@ static void CompareFactoryOverloads(string name, IEnumerable syncMet } } - static void CompareQueryOperators(ILookup syncOperators, ILookup asyncOperators) + private static void CompareQueryOperators(ILookup syncOperators, ILookup asyncOperators) { CompareSets(syncOperators, asyncOperators, CompareQueryOperatorsOverloads); } - static void CompareQueryOperatorsOverloads(string name, IEnumerable syncMethods, IEnumerable asyncMethods) + private static void CompareQueryOperatorsOverloads(string name, IEnumerable syncMethods, IEnumerable asyncMethods) { var sync = GetSignatures(syncMethods).ToArray(); var async = GetRewrittenSignatures(asyncMethods).ToArray(); @@ -171,12 +171,12 @@ static void CompareQueryOperatorsOverloads(string name, IEnumerable } } - static void CompareAggregates(ILookup syncAggregates, ILookup asyncAggregates) + private static void CompareAggregates(ILookup syncAggregates, ILookup asyncAggregates) { CompareSets(syncAggregates, asyncAggregates, CompareAggregateOverloads); } - static void CompareAggregateOverloads(string name, IEnumerable syncMethods, IEnumerable asyncMethods) + private static void CompareAggregateOverloads(string name, IEnumerable syncMethods, IEnumerable asyncMethods) { var sync = GetSignatures(syncMethods).Select(GetAsyncAggregateSignature).ToArray(); var async = GetRewrittenSignatures(asyncMethods).ToArray(); @@ -281,20 +281,16 @@ private static bool IsFuncOrActionType(Type type) private static Signature GetAsyncVariant(Signature signature) { - return new Signature - { - ParameterTypes = signature.ParameterTypes.Select(GetAsyncVariant).ToArray(), - ReturnType = signature.ReturnType - }; + return new Signature( + parameterTypes: signature.ParameterTypes.Select(GetAsyncVariant).ToArray(), + returnType: signature.ReturnType); } private static Signature AppendCancellationToken(Signature signature) { - return new Signature - { - ParameterTypes = signature.ParameterTypes.Concat(new[] { typeof(CancellationToken) }).ToArray(), - ReturnType = signature.ReturnType - }; + return new Signature( + parameterTypes: [.. signature.ParameterTypes, typeof(CancellationToken)], + returnType: signature.ReturnType); } private static Type GetAsyncVariant(Type type) @@ -318,7 +314,7 @@ private static Type GetAsyncVariant(Type type) } else { - return Expression.GetFuncType(args.Append(typeof(Task)).ToArray()); + return Expression.GetFuncType([.. args, typeof(Task)]); } } } @@ -326,7 +322,7 @@ private static Type GetAsyncVariant(Type type) return type; } - static void CompareSets(ILookup sync, ILookup async, Action, IEnumerable> compareCore) + private static void CompareSets(ILookup sync, ILookup async, Action, IEnumerable> compareCore) { var syncNames = sync.Select(g => g.Key).ToArray(); var asyncNames = async.Select(g => g.Key).ToArray(); @@ -374,7 +370,7 @@ static void CompareSets(ILookup sync, ILookup m.Name, m => m), - QueryOperators = queryOperators.ToLookup(m => m.Name, m => m), - Aggregates = aggregates.ToLookup(m => m.Name, m => m), - }; + return new Operators( + Factories: factories.ToLookup(m => m.Name, m => m), + QueryOperators: queryOperators.ToLookup(m => m.Name, m => m), + Aggregates: aggregates.ToLookup(m => m.Name, m => m)); } - static IEnumerable GetSignatures(IEnumerable methods) + private static IEnumerable GetSignatures(IEnumerable methods) { return methods.Select(m => GetSignature(m)); } - static IEnumerable GetRewrittenSignatures(IEnumerable methods) + private static IEnumerable GetRewrittenSignatures(IEnumerable methods) { return GetSignatures(methods).Select(s => RewriteSignature(s)); } - static Signature GetSignature(MethodInfo method) + private static Signature GetSignature(MethodInfo method) { if (method.IsGenericMethodDefinition) { @@ -436,37 +430,31 @@ static Signature GetSignature(MethodInfo method) method = method.MakeGenericMethod(newArgs); } - return new Signature - { - Method = method, - ReturnType = method.ReturnType, - ParameterTypes = method.GetParameters().Select(p => p.ParameterType).ToArray() - }; + return new Signature( + returnType: method.ReturnType, + parameterTypes: method.GetParameters().Select(p => p.ParameterType).ToArray(), + method: method); } - static Signature RewriteSignature(Signature signature) + private static Signature RewriteSignature(Signature signature) { - return new Signature - { - Method = signature.Method, - ReturnType = subst.Visit(signature.ReturnType), - ParameterTypes = subst.Visit(signature.ParameterTypes) - }; + return new Signature( + returnType: Subst.Visit(signature.ReturnType), + parameterTypes: Subst.Visit(signature.ParameterTypes), + method: signature.Method); } - static Signature GetAsyncAggregateSignature(Signature signature) + private static Signature GetAsyncAggregateSignature(Signature signature) { var retType = signature.ReturnType == typeof(void) ? typeof(Task) : typeof(Task<>).MakeGenericType(signature.ReturnType); - return new Signature - { - Method = signature.Method, - ReturnType = retType, - ParameterTypes = signature.ParameterTypes - }; + return new Signature( + returnType: retType, + parameterTypes: signature.ParameterTypes, + method: signature.Method); } - static string ToString(MethodInfo method) + private static string ToString(MethodInfo? method) { if (method == null) { @@ -478,30 +466,31 @@ static string ToString(MethodInfo method) method = method.GetGenericMethodDefinition(); } - return method.ToString(); + return method.ToString() ?? "UNKNOWN"; } - class Operators - { - public ILookup Factories; - public ILookup QueryOperators; - public ILookup Aggregates; - } + private record Operators( + ILookup Factories, + ILookup QueryOperators, + ILookup Aggregates); - class Signature : IEquatable + private class Signature( + Type returnType, + Type[] parameterTypes, + MethodInfo? method = null) : IEquatable { - public MethodInfo Method; - public Type ReturnType; - public Type[] ParameterTypes; + public MethodInfo? Method { get; } = method; + public Type ReturnType { get; } = returnType; + public Type[] ParameterTypes { get; } = parameterTypes; public static bool operator ==(Signature s1, Signature s2) { - if ((object)s1 == null && (object)s2 == null) + if (s1 is null && s2 is null) { return true; } - if ((object)s1 == null || (object)s2 == null) + if (s1 is null || s2 is null) { return false; } @@ -514,24 +503,16 @@ class Signature : IEquatable return !(s1 == s2); } - public bool Equals(Signature s) + public bool Equals(Signature? s) { - return (object)s != null && ReturnType.Equals(s.ReturnType) && ParameterTypes.SequenceEqual(s.ParameterTypes); + return s is not null && ReturnType.Equals(s.ReturnType) && ParameterTypes.SequenceEqual(s.ParameterTypes); } - public override bool Equals(object obj) - { - if (obj is Signature s) - { - return Equals(s); - } - - return false; - } + public override bool Equals(object? obj) => obj is Signature s && Equals(s); public override int GetHashCode() { - return ParameterTypes.Concat(new[] { ReturnType }).Aggregate(0, (a, t) => a * 17 + t.GetHashCode()); + return ParameterTypes.Concat([ReturnType]).Aggregate(0, (a, t) => a * 17 + t.GetHashCode()); } public override string ToString() @@ -540,13 +521,13 @@ public override string ToString() } } - class TypeVisitor + private class TypeVisitor { public virtual Type Visit(Type type) { if (type.IsArray) { - if (type.GetElementType().MakeArrayType() == type) + if (type.GetElementType()!.MakeArrayType() == type) { return VisitArray(type); } @@ -579,12 +560,12 @@ public virtual Type Visit(Type type) protected virtual Type VisitArray(Type type) { - return Visit(type.GetElementType()).MakeArrayType(); + return Visit(type.GetElementType() ?? throw new ArgumentException($"{type} does not have an element type")).MakeArrayType(); } protected virtual Type VisitMultidimensionalArray(Type type) { - return Visit(type.GetElementType()).MakeArrayType(type.GetArrayRank()); + return Visit(type.GetElementType() ?? throw new ArgumentException($"{type} does not have an element type")).MakeArrayType(type.GetArrayRank()); } protected virtual Type VisitGenericTypeDefinition(Type type) @@ -599,12 +580,12 @@ protected virtual Type VisitGeneric(Type type) protected virtual Type VisitByRef(Type type) { - return Visit(type.GetElementType()).MakeByRefType(); + return Visit(type.GetElementType() ?? throw new ArgumentException($"{type} does not have an element type")).MakeByRefType(); } protected virtual Type VisitPointer(Type type) { - return Visit(type.GetElementType()).MakePointerType(); + return Visit(type.GetElementType() ?? throw new ArgumentException($"{type} does not have an element type")).MakePointerType(); } protected virtual Type VisitSimple(Type type) @@ -618,15 +599,8 @@ public Type[] Visit(Type[] types) } } - class TypeSubstitutor : TypeVisitor + private class TypeSubstitutor(Dictionary map) : TypeVisitor { - private readonly Dictionary map; - - public TypeSubstitutor(Dictionary map) - { - this.map = map; - } - public override Type Visit(Type type) { if (map.TryGetValue(type, out var subst)) @@ -638,33 +612,37 @@ public override Type Visit(Type type) } } - private static readonly Type[] Wildcards = new[] { typeof(T1), typeof(T2), typeof(T3), typeof(T4) }; + private static readonly Type[] Wildcards = [typeof(T1), typeof(T2), typeof(T3), typeof(T4)]; + + private class T1 { } + + private class T2 { } + + private class T3 { } - class T1 { } - class T2 { } - class T3 { } - class T4 { } + private class T4 { } } - static class TypeExtensions + internal static class TypeExtensions { public static string ToCSharp(this Type type) { if (type.IsArray) { - if (type.GetElementType().MakeArrayType() == type) + var elementType = type.GetElementType()!; + if (elementType.MakeArrayType() == type) { - return type.GetElementType().ToCSharp() + "[]"; + return elementType.ToCSharp() + "[]"; } else { - return type.GetElementType().ToCSharp() + "[" + new string(',', type.GetArrayRank() - 1) + "]"; + return elementType.ToCSharp() + "[" + new string(',', type.GetArrayRank() - 1) + "]"; } } else if (type.IsConstructedGenericType) { var def = type.GetGenericTypeDefinition(); - var defName = def.Name.Substring(0, def.Name.IndexOf('`')); + var defName = def.Name[..def.Name.IndexOf('`')]; return defName + "<" + string.Join(", ", type.GetGenericArguments().Select(ToCSharp)) + ">"; } diff --git a/Ix.NET/Source/AsyncQueryableGenerator.t4 b/Ix.NET/Source/AsyncQueryableGenerator.t4 index c618619b66..618306f840 100644 --- a/Ix.NET/Source/AsyncQueryableGenerator.t4 +++ b/Ix.NET/Source/AsyncQueryableGenerator.t4 @@ -1,6 +1,7 @@ <#@ assembly name="System.Core" #> <#@ assembly name="System.Runtime" #> <#@ import namespace="System.Linq" #> +<#@ import namespace="System.Reflection" #> <#@ import namespace="System.Text" #> <#@ import namespace="System.Threading" #> <#@ import namespace="System.Threading.Tasks" #> @@ -8,29 +9,67 @@ <# var infoFieldNames = new Dictionary(); -var toQuotedImpl = default(Func); -toQuotedImpl = (t, i, b) => +var toQuotedImpl = default(Func); +toQuotedImpl = (t, paramObjectForAttributes, parameterIndex, notNestedGenericTypeParameter) => { var name = t.Name; +// We always want to look at the whole-type nullability, so we look at that now, and if it's a generic +// type, we'll also go on to inspect per-type-parameter nullability. +var nullableData = paramObjectForAttributes?.GetCustomAttributesData().SingleOrDefault(ad => ad.AttributeType.FullName == "System.Runtime.CompilerServices.NullableAttribute"); +bool wholeTypeNullable = false; +if (nullableData is not null) +{ + if (nullableData.ConstructorArguments[0].Value is IReadOnlyList nullableFlags) + { + // When we end up in this part, the type argument is, in practice, being used as the type argument to + // the actual type. E.g., ValueTask. So we need to look at the second nullable flag. + wholeTypeNullable = ((byte)nullableFlags[1].Value) == 2; + } + else if (nullableData.ConstructorArguments[0].Value is byte bv) + { + wholeTypeNullable = bv == 2; + } +} if (t.IsGenericType) { var genDef = t.GetGenericTypeDefinition(); name = genDef.Name.Substring(0, genDef.Name.LastIndexOf('`')); - var genArgs = "<" + string.Join(", ", t.GetGenericArguments().Select(a => toQuotedImpl(a, i, false))) + ">"; + Type[] genericArguments = t.GetGenericArguments(); + bool[] typeParamsNullable = new bool[genericArguments.Length]; + if (nullableData is not null) + { + if (nullableData.ConstructorArguments[0].Value is IReadOnlyList nullableFlags) + { + // There isn't a 1-1 correspondence between type parameters and nullable flags. Really we should be recursively + // walking the type parameters, but this hack suffices for the types we actually encounter in practice. + int flagIndex = 1; + for (int i = 0; i < typeParamsNullable.Length; ++i) + { + if (!genericArguments[i].IsValueType) + { + if (flagIndex >= nullableFlags.Count) throw new InvalidOperationException($"Type {t} has {typeParamsNullable.Length} type params, but the associated nullable attribute on parameterinto {paramObjectForAttributes} has length {nullableFlags.Count}"); + typeParamsNullable[i] = ((byte)nullableFlags[flagIndex].Value) == 2; + flagIndex += 1; + } + } + } + } + + var genArgs = "<" + string.Join(", ", genericArguments.Select((a, i) => toQuotedImpl(a, null, parameterIndex, false) + (typeParamsNullable[i] ? "?" : ""))) + ">"; - if (b) + if (notNestedGenericTypeParameter) { if (name == "Func" || name == "Action") { name = "Expression<" + name + genArgs + ">"; } - else if (name == "IAsyncEnumerable" && i == 0) + else if (name == "IAsyncEnumerable" && parameterIndex == 0) { name = "IAsyncQueryable" + genArgs; } - else if (name == "IOrderedAsyncEnumerable" && i == 0) + else if (name == "IOrderedAsyncEnumerable" && parameterIndex == 0) { name = "IOrderedAsyncQueryable" + genArgs; } @@ -38,6 +77,8 @@ if (t.IsGenericType) { name += genArgs; } + + //if (wholeTypeNullable) { name += "?"; } } else { @@ -48,12 +89,13 @@ if (t.IsGenericType) else { name += genArgs; + if (wholeTypeNullable) { name += "?"; } } } } else if (t.IsArray) { - var elem = toQuotedImpl(t.GetElementType(), i, b); + var elem = toQuotedImpl(t.GetElementType(), null, parameterIndex, notNestedGenericTypeParameter); name = elem + "[]"; } else @@ -86,12 +128,13 @@ else { name = "object"; } + if (wholeTypeNullable) { name += "?"; } } return name; }; -var toQuoted = new Func((t, i) => toQuotedImpl(t, i, true)); +var toQuoted = new Func((t, paramObjectForAttributes, parameterIndex) => toQuotedImpl(t, paramObjectForAttributes, parameterIndex, true)); #> #nullable enable @@ -125,16 +168,16 @@ foreach (var m in asyncEnumerableType.GetMethods() .OrderBy(m => m.Name) .ThenBy(m => m.IsGenericMethod ? m.GetGenericArguments().Length : 0) .ThenBy(m => m.GetParameters().Length) - .ThenBy(m => string.Join(", ", m.GetParameters().Select((p, i) => toQuoted(p.ParameterType, i) + " " + p.Name)))) + .ThenBy(m => string.Join(", ", m.GetParameters().Select((p, i) => toQuoted(p.ParameterType, p, i) + " " + p.Name)))) { var genArgs = m.GetGenericArguments(); - var ret = toQuoted(m.ReturnType, 0); + var ret = toQuoted(m.ReturnType, m.ReturnParameter, 0); var name = m.Name; if (genArgs.Length > 0) { - name += "<" + string.Join(", ", genArgs.Select(a => a.Name)) + ">"; + name += "<" + string.Join(", ", genArgs.Select((a, i) => a.Name)) + ">"; } var isParams = false; @@ -156,8 +199,8 @@ foreach (var m in asyncEnumerableType.GetMethods() } } - var pars = string.Join(", ", m.GetParameters().Select((p, i) => (i == parCount - 1 && isParams ? "params " : "") + toQuoted(p.ParameterType, i) + (nullableParameterNames.Contains(p.Name) ? "?" : "") + " " + p.Name + (i == parCount - 1 && lastParameterDefault ? " = default" : ""))); - var quotedPars = string.Join(", ", m.GetParameters().Select((p, i) => "default(" + toQuoted(p.ParameterType, i) + ")")); + var pars = string.Join(", ", m.GetParameters().Select((p, i) => (i == parCount - 1 && isParams ? "params " : "") + toQuoted(p.ParameterType, p, i) + (nullableParameterNames.Contains(p.Name) ? "?" : "") + " " + p.Name + (i == parCount - 1 && lastParameterDefault ? " = default" : ""))); + var quotedPars = string.Join(", ", m.GetParameters().Select((p, i) => "default(" + toQuoted(p.ParameterType, p, i) + ")")); if (m.IsDefined(typeof(System.Runtime.CompilerServices.ExtensionAttribute), true)) { @@ -193,7 +236,7 @@ foreach (var m in asyncEnumerableType.GetMethods() infoName += infoNameId; - var infoSignature = string.Join(", ", m.GetParameters().Select((p, i) => toQuoted(p.ParameterType, i)).Concat(new[] { toQuoted(m.ReturnType, 0) })); + var infoSignature = string.Join(", ", m.GetParameters().Select((p, i) => toQuoted(p.ParameterType, p, i)).Concat(new[] { toQuoted(m.ReturnType, m.ReturnParameter, 0) })); foreach (var genArg in genArgs) { @@ -219,7 +262,7 @@ foreach (var m in asyncEnumerableType.GetMethods() if (td.Name.EndsWith("Task`1")) // NB: Covers Task and ValueTask { - factory = "ExecuteAsync<" + toQuotedImpl(m.ReturnType.GetGenericArguments()[0], -1, false) + ">"; + factory = "ExecuteAsync<" + toQuotedImpl(m.ReturnType.GetGenericArguments()[0], m.ReturnParameter, -1, false) + ">"; var last = m.GetParameters().Last(); if (last.ParameterType == typeof(CancellationToken)) @@ -233,11 +276,11 @@ foreach (var m in asyncEnumerableType.GetMethods() } else if (td == typeof(IAsyncEnumerable<>) || td == typeof(IOrderedAsyncEnumerable<>)) { - factory = "CreateQuery<" + toQuotedImpl(m.ReturnType.GetGenericArguments()[0], -1, false) + ">"; + factory = "CreateQuery<" + toQuotedImpl(m.ReturnType.GetGenericArguments()[0], null, -1, false) + ">"; if (td == typeof(IOrderedAsyncEnumerable<>)) { - cast = "(" + toQuoted(m.ReturnType, 0) + ")"; + cast = "(" + toQuoted(m.ReturnType, null, 0) + ")"; } } } @@ -274,7 +317,7 @@ foreach (var m in asyncEnumerableType.GetMethods() if (!add) { - quotedArgs.Add("Expression.Constant(" + p.Name + ", typeof(" + toQuoted(pt, -1) + "))"); + quotedArgs.Add("Expression.Constant(" + p.Name + ", typeof(" + toQuoted(pt, null, -1) + "))"); } n++; diff --git a/Ix.NET/Source/Directory.Build.props b/Ix.NET/Source/Directory.Build.props index 992f96c76f..b21a713515 100644 --- a/Ix.NET/Source/Directory.Build.props +++ b/Ix.NET/Source/Directory.Build.props @@ -10,7 +10,11 @@ true true $(MSBuildThisFileDirectory)ReactiveX.snk - $(NoWarn);1701;1702;CS1591;NU5105 + + $(NoWarn);1701;1702;CS1591;NU5105;IDE0056;IDE0270 en-US $(MSBuildProjectName.Contains('Test')) true diff --git a/Ix.NET/Source/FasterLinq/FasterLinq.csproj b/Ix.NET/Source/FasterLinq/FasterLinq.csproj index 74954604db..8735c44675 100644 --- a/Ix.NET/Source/FasterLinq/FasterLinq.csproj +++ b/Ix.NET/Source/FasterLinq/FasterLinq.csproj @@ -3,6 +3,8 @@ Exe net6.0 + + $(NoWarn);IDE0007;IDE0034;IDE0040;IDE0063;IDE0090;IDE1006 diff --git a/Ix.NET/Source/FasterLinq/Program.cs b/Ix.NET/Source/FasterLinq/Program.cs index 4e330ff337..dfacfc289c 100644 --- a/Ix.NET/Source/FasterLinq/Program.cs +++ b/Ix.NET/Source/FasterLinq/Program.cs @@ -4,6 +4,8 @@ #nullable disable +#pragma warning disable CS0436 // Interface definitions conflict with .NET Runtime. This brings its own older definitions of various async interfaces. + using System; using System.Collections; using System.Collections.Generic; @@ -15,7 +17,7 @@ namespace FasterLinq { class Program { - static void Main(string[] args) + static void Main() { var N = 4; @@ -808,12 +810,9 @@ public static async Task Aggregate(this IAsyncEnumerable source, R s try { - while (true) + while (await e.MoveNextAsync().ConfigureAwait(false)) { - while (await e.MoveNextAsync().ConfigureAwait(false)) - { - res = await aggregate(res, e.Current).ConfigureAwait(false); - } + res = await aggregate(res, e.Current).ConfigureAwait(false); } } finally diff --git a/Ix.NET/Source/Ix.NET.sln b/Ix.NET/Source/Ix.NET.sln index 32435c26dd..7a30f4c92c 100644 --- a/Ix.NET/Source/Ix.NET.sln +++ b/Ix.NET/Source/Ix.NET.sln @@ -4,6 +4,9 @@ Microsoft Visual Studio Solution File, Format Version 12.00 VisualStudioVersion = 17.2.32131.331 MinimumVisualStudioVersion = 10.0.40219.1 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{87534290-A7A6-47A4-9A3A-D0D21A9AD1D4}" + ProjectSection(SolutionItems) = preProject + NetCore31TestReadme.txt = NetCore31TestReadme.txt + EndProjectSection EndProject Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{B733D97A-F1ED-4FC3-BF8E-9AC47A89DE96}" ProjectSection(SolutionItems) = preProject @@ -12,15 +15,20 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution CodeCoverage.runsettings = CodeCoverage.runsettings Directory.build.props = Directory.build.props Directory.build.targets = Directory.build.targets - global.json = global.json version.json = version.json EndProjectSection EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Interactive", "System.Interactive\System.Interactive.csproj", "{FF97CD0F-8108-4B66-8A34-42190B459180}" + ProjectSection(ProjectDependencies) = postProject + {2EC0C302-B029-4DDB-AC91-000BF11006AD} = {2EC0C302-B029-4DDB-AC91-000BF11006AD} + EndProjectSection EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Interactive.Async", "System.Interactive.Async\System.Interactive.Async.csproj", "{A9F6D09B-15B9-4CE8-867F-6F3383C5F247}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Interactive.Providers", "System.Interactive.Providers\System.Interactive.Providers.csproj", "{CA7B7136-13EE-4F01-BC22-722875EE8569}" + ProjectSection(ProjectDependencies) = postProject + {5DF341BE-B369-4250-AFD4-604DE8C95E45} = {5DF341BE-B369-4250-AFD4-604DE8C95E45} + EndProjectSection EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Interactive.Async.Providers", "System.Interactive.Async.Providers\System.Interactive.Async.Providers.csproj", "{33691BB5-DD5B-4FED-8EE3-52CEE0DE2550}" EndProject @@ -29,6 +37,9 @@ EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Interactive.Async.Tests", "System.Interactive.Async.Tests\System.Interactive.Async.Tests.csproj", "{172BD8C4-5C3E-4928-9D3F-746CF336FFEC}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Linq.Async", "System.Linq.Async\System.Linq.Async.csproj", "{9B1E5420-E8F3-4B5F-A11A-4D18578F50CE}" + ProjectSection(ProjectDependencies) = postProject + {1754B36C-D0DB-4E5D-8C30-1F116046DC0F} = {1754B36C-D0DB-4E5D-8C30-1F116046DC0F} + EndProjectSection EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Linq.Async.Queryable", "System.Linq.Async.Queryable\System.Linq.Async.Queryable.csproj", "{513F9ABD-4FB8-4AC1-89DA-C3300399F34C}" EndProject @@ -53,16 +64,18 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Refs", "Refs", "{A3D72E6E-4 refs\Directory.build.props = refs\Directory.build.props EndProjectSection EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Interactive", "refs\System.Interactive.Ref\System.Interactive.csproj", "{2EC0C302-B029-4DDB-AC91-000BF11006AD}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Interactive", "refs\System.Interactive\System.Interactive.csproj", "{2EC0C302-B029-4DDB-AC91-000BF11006AD}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Interactive.Providers", "refs\System.Interactive.Providers.Ref\System.Interactive.Providers.csproj", "{5DF341BE-B369-4250-AFD4-604DE8C95E45}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Interactive.Providers", "refs\System.Interactive.Providers\System.Interactive.Providers.csproj", "{5DF341BE-B369-4250-AFD4-604DE8C95E45}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Benchmarks.System.Interactive", "Benchmarks.System.Interactive\Benchmarks.System.Interactive.csproj", "{3285529A-8227-4D40-B524-1A1F919F0E7B}" EndProject -Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Linq.Async", "refs\System.Linq.Async.Ref\System.Linq.Async.csproj", "{1754B36C-D0DB-4E5D-8C30-1F116046DC0F}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Linq.Async", "refs\System.Linq.Async\System.Linq.Async.csproj", "{1754B36C-D0DB-4E5D-8C30-1F116046DC0F}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Linq.Async.SourceGenerator", "System.Linq.Async.SourceGenerator\System.Linq.Async.SourceGenerator.csproj", "{5C26D649-5ED4-49EE-AFBD-8FA8F12C4AE4}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Tests.System.Interactive.ApiApprovals", "Tests.System.Interactive.ApiApprovals\Tests.System.Interactive.ApiApprovals.csproj", "{CD146918-6465-4D5B-B6B7-3F9803095EBD}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -134,13 +147,15 @@ Global {3285529A-8227-4D40-B524-1A1F919F0E7B}.Release|Any CPU.ActiveCfg = Current Sources|Any CPU {3285529A-8227-4D40-B524-1A1F919F0E7B}.Release|Any CPU.Build.0 = Current Sources|Any CPU {1754B36C-D0DB-4E5D-8C30-1F116046DC0F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {1754B36C-D0DB-4E5D-8C30-1F116046DC0F}.Debug|Any CPU.Build.0 = Debug|Any CPU {1754B36C-D0DB-4E5D-8C30-1F116046DC0F}.Release|Any CPU.ActiveCfg = Release|Any CPU - {1754B36C-D0DB-4E5D-8C30-1F116046DC0F}.Release|Any CPU.Build.0 = Release|Any CPU {5C26D649-5ED4-49EE-AFBD-8FA8F12C4AE4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {5C26D649-5ED4-49EE-AFBD-8FA8F12C4AE4}.Debug|Any CPU.Build.0 = Debug|Any CPU {5C26D649-5ED4-49EE-AFBD-8FA8F12C4AE4}.Release|Any CPU.ActiveCfg = Release|Any CPU {5C26D649-5ED4-49EE-AFBD-8FA8F12C4AE4}.Release|Any CPU.Build.0 = Release|Any CPU + {CD146918-6465-4D5B-B6B7-3F9803095EBD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {CD146918-6465-4D5B-B6B7-3F9803095EBD}.Debug|Any CPU.Build.0 = Debug|Any CPU + {CD146918-6465-4D5B-B6B7-3F9803095EBD}.Release|Any CPU.ActiveCfg = Release|Any CPU + {CD146918-6465-4D5B-B6B7-3F9803095EBD}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -164,6 +179,7 @@ Global {5DF341BE-B369-4250-AFD4-604DE8C95E45} = {A3D72E6E-4ADA-42E0-8B2A-055B1F244281} {1754B36C-D0DB-4E5D-8C30-1F116046DC0F} = {A3D72E6E-4ADA-42E0-8B2A-055B1F244281} {5C26D649-5ED4-49EE-AFBD-8FA8F12C4AE4} = {80EFE3A1-1414-42EA-949B-1B5370A1B2EA} + {CD146918-6465-4D5B-B6B7-3F9803095EBD} = {87534290-A7A6-47A4-9A3A-D0D21A9AD1D4} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {AF70B0C6-C9D9-43B1-9BE4-08720EC1B7B7} diff --git a/Ix.NET/Source/NetCore31TestReadme.txt b/Ix.NET/Source/NetCore31TestReadme.txt new file mode 100644 index 0000000000..259965ef4e --- /dev/null +++ b/Ix.NET/Source/NetCore31TestReadme.txt @@ -0,0 +1,7 @@ +The tests all include a .NET Core 3.1 target, even though that has long since been out of support. + +The reason for this is that Ix.NET 6.0 offers a .NET Standard 2.1 target, and currently, the only way we have of testing this is through .NET Core 3.1. + +Although current versions of .NET (but not .NET Framework) support .NET Standard 2.1, they are all going to prefer the net6.0 target. We do test on currently supported versions of .NET, but we also want to test the .NET Standard 2.1 target. + +It might be possible to test via Mono instead, or possibly even Unity, but this would likely involve additional CI/CD work, so for now we're sticking with the .NET Core 3.1 target framework. It's unsupported, but it's better than doing no testing at all. \ No newline at end of file diff --git a/Ix.NET/Source/Playground/DemoAttribute.cs b/Ix.NET/Source/Playground/DemoAttribute.cs index 300e4d1191..f518a77719 100644 --- a/Ix.NET/Source/Playground/DemoAttribute.cs +++ b/Ix.NET/Source/Playground/DemoAttribute.cs @@ -7,15 +7,9 @@ namespace Playground { [AttributeUsage(AttributeTargets.Method)] - internal sealed class DemoAttribute : Attribute + internal sealed class DemoAttribute(int index, string title) : Attribute { - public DemoAttribute(int index, string title) - { - Index = index; - Title = title; - } - - public int Index { get; } - public string Title { get; } + public int Index { get; } = index; + public string Title { get; } = title; } } diff --git a/Ix.NET/Source/Playground/Playground.csproj b/Ix.NET/Source/Playground/Playground.csproj index 495d7d0ead..174cbcc1fd 100644 --- a/Ix.NET/Source/Playground/Playground.csproj +++ b/Ix.NET/Source/Playground/Playground.csproj @@ -2,7 +2,7 @@ Exe - net6.0 + net8.0 diff --git a/Ix.NET/Source/Playground/Program.cs b/Ix.NET/Source/Playground/Program.cs index aadf1135c7..eb0dc304ed 100644 --- a/Ix.NET/Source/Playground/Program.cs +++ b/Ix.NET/Source/Playground/Program.cs @@ -2,6 +2,8 @@ // The .NET Foundation licenses this file to you under the MIT License. // See the LICENSE file in the project root for more information. +#pragma warning disable IDE0051 // Remove unused private members - all used via reflection + using System; using System.Collections.Generic; using System.Linq; @@ -10,22 +12,22 @@ namespace Playground { - class Program + internal class Program { - static void Main() + private static void Main() { RunDemos(); } [Demo(0, "Random experimentation")] - static async Task Experiment() + private static async Task Experiment() { // Add test code here await Task.Yield(); // Suppress CS1998 } [Demo(11, "LINQ to Objects for IEnumerable")] - static void Linq() + private static void Linq() { var xs = new List { 1, 2, 3 }; var ys = xs.Where(x => x % 2 == 0); @@ -37,7 +39,7 @@ static void Linq() } [Demo(12, "LINQ to Objects for IQueryable")] - static void LinqQueryable() + private static void LinqQueryable() { var xs = new List { 1, 2, 3 }.AsQueryable(); var ys = xs.Where(x => x % 2 == 0); @@ -49,7 +51,7 @@ static void LinqQueryable() } [Demo(21, "LINQ to Objects for IEnumerable - Interactive Extensions")] - static void Ix() + private static void Ix() { var xs = new List { 1, 2, 3 }; var ys = xs.Distinct(x => x % 2); @@ -61,7 +63,7 @@ static void Ix() } [Demo(22, "LINQ to Objects for IQueryable - Interactive Extensions")] - static void IxQueryable() + private static void IxQueryable() { var xs = new List { 1, 2, 3 }.AsQueryable(); var ys = xs.Distinct(x => x % 2); @@ -73,7 +75,7 @@ static void IxQueryable() } [Demo(31, "LINQ to Objects for IAsyncEnumerable")] - static async Task AsyncLinq() + private static async Task AsyncLinq() { var xs = new List { 1, 2, 3 }; var ys = xs.ToAsyncEnumerable().Where(x => x % 2 == 0); @@ -103,7 +105,7 @@ static async Task AsyncLinq() } [Demo(32, "LINQ to Objects for IAsyncQueryable")] - static async Task AsyncLinqQueryable() + private static async Task AsyncLinqQueryable() { var xs = new List { 1, 2, 3 }.AsQueryable(); var ys = xs.ToAsyncEnumerable().Where(x => x % 2 == 0); @@ -133,7 +135,7 @@ static async Task AsyncLinqQueryable() } [Demo(41, "LINQ to Objects for IAsyncEnumerable - Interactive Extensions")] - static async Task AsyncIx() + private static async Task AsyncIx() { var xs = new List { 1, 2, 3 }; var ys = xs.ToAsyncEnumerable().Distinct(x => x % 2); @@ -152,7 +154,7 @@ await ys.ForEachAsync(y => } [Demo(42, "LINQ to Objects for IAsyncQueryable - Interactive Extensions")] - static async Task AsyncIxQueryable() + private static async Task AsyncIxQueryable() { var xs = new List { 1, 2, 3 }.AsQueryable(); var ys = xs.ToAsyncEnumerable().Distinct(x => x % 2); @@ -170,7 +172,7 @@ await ys.ForEachAsync(y => #endif } - static void RunDemos() + private static void RunDemos() { var methods = (from method in typeof(Program).GetTypeInfo().GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static) let demo = method.GetCustomAttribute() @@ -197,7 +199,7 @@ orderby demo.Index while (retry) { Console.Write("Enter demo [C: Clear, X: Exit]: "); - var input = Console.ReadLine().Trim().ToUpper(); + var input = Console.ReadLine()?.Trim().ToUpper(); switch (input) { diff --git a/Ix.NET/Source/System.Interactive.Async.Providers.Tests/System.Interactive.Async.Providers.Tests.csproj b/Ix.NET/Source/System.Interactive.Async.Providers.Tests/System.Interactive.Async.Providers.Tests.csproj index f2e562ca3c..5ddd5cf4e9 100644 --- a/Ix.NET/Source/System.Interactive.Async.Providers.Tests/System.Interactive.Async.Providers.Tests.csproj +++ b/Ix.NET/Source/System.Interactive.Async.Providers.Tests/System.Interactive.Async.Providers.Tests.csproj @@ -1,7 +1,8 @@  - net48;net6.0;netcoreapp3.1 + + net48;net8.0;net6.0;netcoreapp3.1 $(NoWarn);CS0618 diff --git a/Ix.NET/Source/System.Interactive.Async.Providers/System.Interactive.Async.Providers.csproj b/Ix.NET/Source/System.Interactive.Async.Providers/System.Interactive.Async.Providers.csproj index 73c0db2620..5e214f9414 100644 --- a/Ix.NET/Source/System.Interactive.Async.Providers/System.Interactive.Async.Providers.csproj +++ b/Ix.NET/Source/System.Interactive.Async.Providers/System.Interactive.Async.Providers.csproj @@ -21,4 +21,8 @@ + + + + diff --git a/Ix.NET/Source/System.Interactive.Async.Providers/System/Linq/AsyncQueryableEx.Generated.cs b/Ix.NET/Source/System.Interactive.Async.Providers/System/Linq/AsyncQueryableEx.Generated.cs index cdbe5afa11..856cf3513e 100644 --- a/Ix.NET/Source/System.Interactive.Async.Providers/System/Linq/AsyncQueryableEx.Generated.cs +++ b/Ix.NET/Source/System.Interactive.Async.Providers/System/Linq/AsyncQueryableEx.Generated.cs @@ -16,7 +16,7 @@ public static partial class AsyncQueryableEx { private static MethodInfo? s_Amb__TSource__2__0; - private static MethodInfo? Amb__TSource__2__0(Type TSource) => + private static MethodInfo Amb__TSource__2__0(Type TSource) => (s_Amb__TSource__2__0 ?? (s_Amb__TSource__2__0 = new Func, IAsyncEnumerable, IAsyncQueryable>(Amb).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -32,7 +32,7 @@ public static IAsyncQueryable Amb(this IAsyncQueryable + private static MethodInfo Buffer__TSource__2__0(Type TSource) => (s_Buffer__TSource__2__0 ?? (s_Buffer__TSource__2__0 = new Func, int, IAsyncQueryable>>(Buffer).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -46,7 +46,7 @@ public static IAsyncQueryable> Buffer(this IAsyncQueryab private static MethodInfo? s_Buffer__TSource__3__0; - private static MethodInfo? Buffer__TSource__3__0(Type TSource) => + private static MethodInfo Buffer__TSource__3__0(Type TSource) => (s_Buffer__TSource__3__0 ?? (s_Buffer__TSource__3__0 = new Func, int, int, IAsyncQueryable>>(Buffer).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -60,7 +60,7 @@ public static IAsyncQueryable> Buffer(this IAsyncQueryab private static MethodInfo? s_Catch__TSource__2__0; - private static MethodInfo? Catch__TSource__2__0(Type TSource) => + private static MethodInfo Catch__TSource__2__0(Type TSource) => (s_Catch__TSource__2__0 ?? (s_Catch__TSource__2__0 = new Func, IAsyncEnumerable, IAsyncQueryable>(Catch).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -76,7 +76,7 @@ public static IAsyncQueryable Catch(this IAsyncQueryable + private static MethodInfo Catch__TSource_TException__2__0(Type TSource, Type TException) => (s_Catch__TSource_TException__2__0 ?? (s_Catch__TSource_TException__2__0 = new Func, Expression>>>, IAsyncQueryable>(Catch).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TException); @@ -92,7 +92,7 @@ public static IAsyncQueryable Catch(this IAsyncQue private static MethodInfo? s_Catch__TSource_TException__2__1; - private static MethodInfo? Catch__TSource_TException__2__1(Type TSource, Type TException) => + private static MethodInfo Catch__TSource_TException__2__1(Type TSource, Type TException) => (s_Catch__TSource_TException__2__1 ?? (s_Catch__TSource_TException__2__1 = new Func, Expression>>, IAsyncQueryable>(Catch).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TException); @@ -108,7 +108,7 @@ public static IAsyncQueryable Catch(this IAsyncQue private static MethodInfo? s_Catch__TSource_TException__2__2; - private static MethodInfo? Catch__TSource_TException__2__2(Type TSource, Type TException) => + private static MethodInfo Catch__TSource_TException__2__2(Type TSource, Type TException) => (s_Catch__TSource_TException__2__2 ?? (s_Catch__TSource_TException__2__2 = new Func, Expression>>>, IAsyncQueryable>(Catch).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TException); @@ -124,7 +124,7 @@ public static IAsyncQueryable Catch(this IAsyncQue private static MethodInfo? s_Concat__TSource__1__0; - private static MethodInfo? Concat__TSource__1__0(Type TSource) => + private static MethodInfo Concat__TSource__1__0(Type TSource) => (s_Concat__TSource__1__0 ?? (s_Concat__TSource__1__0 = new Func>, IAsyncQueryable>(Concat).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -138,7 +138,7 @@ public static IAsyncQueryable Concat(this IAsyncQueryable + private static MethodInfo Distinct__TSource_TKey__2__0(Type TSource, Type TKey) => (s_Distinct__TSource_TKey__2__0 ?? (s_Distinct__TSource_TKey__2__0 = new Func, Expression>>, IAsyncQueryable>(Distinct).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -154,7 +154,7 @@ public static IAsyncQueryable Distinct(this IAsyncQuerya private static MethodInfo? s_Distinct__TSource_TKey__2__1; - private static MethodInfo? Distinct__TSource_TKey__2__1(Type TSource, Type TKey) => + private static MethodInfo Distinct__TSource_TKey__2__1(Type TSource, Type TKey) => (s_Distinct__TSource_TKey__2__1 ?? (s_Distinct__TSource_TKey__2__1 = new Func, Expression>, IAsyncQueryable>(Distinct).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -170,7 +170,7 @@ public static IAsyncQueryable Distinct(this IAsyncQuerya private static MethodInfo? s_Distinct__TSource_TKey__2__2; - private static MethodInfo? Distinct__TSource_TKey__2__2(Type TSource, Type TKey) => + private static MethodInfo Distinct__TSource_TKey__2__2(Type TSource, Type TKey) => (s_Distinct__TSource_TKey__2__2 ?? (s_Distinct__TSource_TKey__2__2 = new Func, Expression>>, IAsyncQueryable>(Distinct).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -186,7 +186,7 @@ public static IAsyncQueryable Distinct(this IAsyncQuerya private static MethodInfo? s_Distinct__TSource_TKey__3__0; - private static MethodInfo? Distinct__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo Distinct__TSource_TKey__3__0(Type TSource, Type TKey) => (s_Distinct__TSource_TKey__3__0 ?? (s_Distinct__TSource_TKey__3__0 = new Func, Expression>>, IEqualityComparer, IAsyncQueryable>(Distinct).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -202,7 +202,7 @@ public static IAsyncQueryable Distinct(this IAsyncQuerya private static MethodInfo? s_Distinct__TSource_TKey__3__1; - private static MethodInfo? Distinct__TSource_TKey__3__1(Type TSource, Type TKey) => + private static MethodInfo Distinct__TSource_TKey__3__1(Type TSource, Type TKey) => (s_Distinct__TSource_TKey__3__1 ?? (s_Distinct__TSource_TKey__3__1 = new Func, Expression>, IEqualityComparer, IAsyncQueryable>(Distinct).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -218,7 +218,7 @@ public static IAsyncQueryable Distinct(this IAsyncQuerya private static MethodInfo? s_Distinct__TSource_TKey__3__2; - private static MethodInfo? Distinct__TSource_TKey__3__2(Type TSource, Type TKey) => + private static MethodInfo Distinct__TSource_TKey__3__2(Type TSource, Type TKey) => (s_Distinct__TSource_TKey__3__2 ?? (s_Distinct__TSource_TKey__3__2 = new Func, Expression>>, IEqualityComparer, IAsyncQueryable>(Distinct).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -234,7 +234,7 @@ public static IAsyncQueryable Distinct(this IAsyncQuerya private static MethodInfo? s_DistinctUntilChanged__TSource__1__0; - private static MethodInfo? DistinctUntilChanged__TSource__1__0(Type TSource) => + private static MethodInfo DistinctUntilChanged__TSource__1__0(Type TSource) => (s_DistinctUntilChanged__TSource__1__0 ?? (s_DistinctUntilChanged__TSource__1__0 = new Func, IAsyncQueryable>(DistinctUntilChanged).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -248,7 +248,7 @@ public static IAsyncQueryable DistinctUntilChanged(this IAsync private static MethodInfo? s_DistinctUntilChanged__TSource__2__0; - private static MethodInfo? DistinctUntilChanged__TSource__2__0(Type TSource) => + private static MethodInfo DistinctUntilChanged__TSource__2__0(Type TSource) => (s_DistinctUntilChanged__TSource__2__0 ?? (s_DistinctUntilChanged__TSource__2__0 = new Func, IEqualityComparer, IAsyncQueryable>(DistinctUntilChanged).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -262,7 +262,7 @@ public static IAsyncQueryable DistinctUntilChanged(this IAsync private static MethodInfo? s_DistinctUntilChanged__TSource_TKey__2__0; - private static MethodInfo? DistinctUntilChanged__TSource_TKey__2__0(Type TSource, Type TKey) => + private static MethodInfo DistinctUntilChanged__TSource_TKey__2__0(Type TSource, Type TKey) => (s_DistinctUntilChanged__TSource_TKey__2__0 ?? (s_DistinctUntilChanged__TSource_TKey__2__0 = new Func, Expression>>, IAsyncQueryable>(DistinctUntilChanged).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -278,7 +278,7 @@ public static IAsyncQueryable DistinctUntilChanged(this private static MethodInfo? s_DistinctUntilChanged__TSource_TKey__2__1; - private static MethodInfo? DistinctUntilChanged__TSource_TKey__2__1(Type TSource, Type TKey) => + private static MethodInfo DistinctUntilChanged__TSource_TKey__2__1(Type TSource, Type TKey) => (s_DistinctUntilChanged__TSource_TKey__2__1 ?? (s_DistinctUntilChanged__TSource_TKey__2__1 = new Func, Expression>, IAsyncQueryable>(DistinctUntilChanged).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -294,7 +294,7 @@ public static IAsyncQueryable DistinctUntilChanged(this private static MethodInfo? s_DistinctUntilChanged__TSource_TKey__2__2; - private static MethodInfo? DistinctUntilChanged__TSource_TKey__2__2(Type TSource, Type TKey) => + private static MethodInfo DistinctUntilChanged__TSource_TKey__2__2(Type TSource, Type TKey) => (s_DistinctUntilChanged__TSource_TKey__2__2 ?? (s_DistinctUntilChanged__TSource_TKey__2__2 = new Func, Expression>>, IAsyncQueryable>(DistinctUntilChanged).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -310,7 +310,7 @@ public static IAsyncQueryable DistinctUntilChanged(this private static MethodInfo? s_DistinctUntilChanged__TSource_TKey__3__0; - private static MethodInfo? DistinctUntilChanged__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo DistinctUntilChanged__TSource_TKey__3__0(Type TSource, Type TKey) => (s_DistinctUntilChanged__TSource_TKey__3__0 ?? (s_DistinctUntilChanged__TSource_TKey__3__0 = new Func, Expression>>, IEqualityComparer, IAsyncQueryable>(DistinctUntilChanged).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -326,7 +326,7 @@ public static IAsyncQueryable DistinctUntilChanged(this private static MethodInfo? s_DistinctUntilChanged__TSource_TKey__3__1; - private static MethodInfo? DistinctUntilChanged__TSource_TKey__3__1(Type TSource, Type TKey) => + private static MethodInfo DistinctUntilChanged__TSource_TKey__3__1(Type TSource, Type TKey) => (s_DistinctUntilChanged__TSource_TKey__3__1 ?? (s_DistinctUntilChanged__TSource_TKey__3__1 = new Func, Expression>, IEqualityComparer, IAsyncQueryable>(DistinctUntilChanged).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -342,7 +342,7 @@ public static IAsyncQueryable DistinctUntilChanged(this private static MethodInfo? s_DistinctUntilChanged__TSource_TKey__3__2; - private static MethodInfo? DistinctUntilChanged__TSource_TKey__3__2(Type TSource, Type TKey) => + private static MethodInfo DistinctUntilChanged__TSource_TKey__3__2(Type TSource, Type TKey) => (s_DistinctUntilChanged__TSource_TKey__3__2 ?? (s_DistinctUntilChanged__TSource_TKey__3__2 = new Func, Expression>>, IEqualityComparer, IAsyncQueryable>(DistinctUntilChanged).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -358,7 +358,7 @@ public static IAsyncQueryable DistinctUntilChanged(this private static MethodInfo? s_Do__TSource__2__0; - private static MethodInfo? Do__TSource__2__0(Type TSource) => + private static MethodInfo Do__TSource__2__0(Type TSource) => (s_Do__TSource__2__0 ?? (s_Do__TSource__2__0 = new Func, Expression>, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -374,7 +374,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Do__TSource__2__1; - private static MethodInfo? Do__TSource__2__1(Type TSource) => + private static MethodInfo Do__TSource__2__1(Type TSource) => (s_Do__TSource__2__1 ?? (s_Do__TSource__2__1 = new Func, Expression>, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -390,7 +390,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Do__TSource__2__2; - private static MethodInfo? Do__TSource__2__2(Type TSource) => + private static MethodInfo Do__TSource__2__2(Type TSource) => (s_Do__TSource__2__2 ?? (s_Do__TSource__2__2 = new Func, Expression>, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -406,7 +406,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Do__TSource__2__3; - private static MethodInfo? Do__TSource__2__3(Type TSource) => + private static MethodInfo Do__TSource__2__3(Type TSource) => (s_Do__TSource__2__3 ?? (s_Do__TSource__2__3 = new Func, IObserver, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -422,7 +422,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Do__TSource__3__0; - private static MethodInfo? Do__TSource__3__0(Type TSource) => + private static MethodInfo Do__TSource__3__0(Type TSource) => (s_Do__TSource__3__0 ?? (s_Do__TSource__3__0 = new Func, Expression>, Action, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -440,7 +440,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Do__TSource__3__1; - private static MethodInfo? Do__TSource__3__1(Type TSource) => + private static MethodInfo Do__TSource__3__1(Type TSource) => (s_Do__TSource__3__1 ?? (s_Do__TSource__3__1 = new Func, Expression>, Expression>, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -458,7 +458,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Do__TSource__3__2; - private static MethodInfo? Do__TSource__3__2(Type TSource) => + private static MethodInfo Do__TSource__3__2(Type TSource) => (s_Do__TSource__3__2 ?? (s_Do__TSource__3__2 = new Func, Expression>, Expression>, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -476,7 +476,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Do__TSource__3__3; - private static MethodInfo? Do__TSource__3__3(Type TSource) => + private static MethodInfo Do__TSource__3__3(Type TSource) => (s_Do__TSource__3__3 ?? (s_Do__TSource__3__3 = new Func, Expression>, Expression>, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -494,7 +494,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Do__TSource__3__4; - private static MethodInfo? Do__TSource__3__4(Type TSource) => + private static MethodInfo Do__TSource__3__4(Type TSource) => (s_Do__TSource__3__4 ?? (s_Do__TSource__3__4 = new Func, Expression>, Expression>, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -512,7 +512,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Do__TSource__3__5; - private static MethodInfo? Do__TSource__3__5(Type TSource) => + private static MethodInfo Do__TSource__3__5(Type TSource) => (s_Do__TSource__3__5 ?? (s_Do__TSource__3__5 = new Func, Expression>, Expression>, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -530,7 +530,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Do__TSource__4__0; - private static MethodInfo? Do__TSource__4__0(Type TSource) => + private static MethodInfo Do__TSource__4__0(Type TSource) => (s_Do__TSource__4__0 ?? (s_Do__TSource__4__0 = new Func, Expression>, Expression>, Action, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -550,7 +550,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Do__TSource__4__1; - private static MethodInfo? Do__TSource__4__1(Type TSource) => + private static MethodInfo Do__TSource__4__1(Type TSource) => (s_Do__TSource__4__1 ?? (s_Do__TSource__4__1 = new Func, Expression>, Expression>, Expression>, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -570,7 +570,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Do__TSource__4__2; - private static MethodInfo? Do__TSource__4__2(Type TSource) => + private static MethodInfo Do__TSource__4__2(Type TSource) => (s_Do__TSource__4__2 ?? (s_Do__TSource__4__2 = new Func, Expression>, Expression>, Expression>, IAsyncQueryable>(Do).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -590,7 +590,7 @@ public static IAsyncQueryable Do(this IAsyncQueryable private static MethodInfo? s_Expand__TSource__2__0; - private static MethodInfo? Expand__TSource__2__0(Type TSource) => + private static MethodInfo Expand__TSource__2__0(Type TSource) => (s_Expand__TSource__2__0 ?? (s_Expand__TSource__2__0 = new Func, Expression>>>, IAsyncQueryable>(Expand).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -606,7 +606,7 @@ public static IAsyncQueryable Expand(this IAsyncQueryable + private static MethodInfo Expand__TSource__2__1(Type TSource) => (s_Expand__TSource__2__1 ?? (s_Expand__TSource__2__1 = new Func, Expression>>, IAsyncQueryable>(Expand).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -622,7 +622,7 @@ public static IAsyncQueryable Expand(this IAsyncQueryable + private static MethodInfo Expand__TSource__2__2(Type TSource) => (s_Expand__TSource__2__2 ?? (s_Expand__TSource__2__2 = new Func, Expression>>>, IAsyncQueryable>(Expand).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -638,7 +638,7 @@ public static IAsyncQueryable Expand(this IAsyncQueryable + private static MethodInfo Finally__TSource__2__0(Type TSource) => (s_Finally__TSource__2__0 ?? (s_Finally__TSource__2__0 = new Func, Action, IAsyncQueryable>(Finally).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -654,7 +654,7 @@ public static IAsyncQueryable Finally(this IAsyncQueryable + private static MethodInfo Finally__TSource__2__1(Type TSource) => (s_Finally__TSource__2__1 ?? (s_Finally__TSource__2__1 = new Func, Expression>, IAsyncQueryable>(Finally).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -670,7 +670,7 @@ public static IAsyncQueryable Finally(this IAsyncQueryable + private static MethodInfo IgnoreElements__TSource__1__0(Type TSource) => (s_IgnoreElements__TSource__1__0 ?? (s_IgnoreElements__TSource__1__0 = new Func, IAsyncQueryable>(IgnoreElements).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -684,7 +684,7 @@ public static IAsyncQueryable IgnoreElements(this IAsyncQuerya private static MethodInfo? s_IsEmptyAsync__TSource__2__0; - private static MethodInfo? IsEmptyAsync__TSource__2__0(Type TSource) => + private static MethodInfo IsEmptyAsync__TSource__2__0(Type TSource) => (s_IsEmptyAsync__TSource__2__0 ?? (s_IsEmptyAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(IsEmptyAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -698,7 +698,7 @@ public static ValueTask IsEmptyAsync(this IAsyncQueryable + private static MethodInfo MaxAsync__TSource__3__0(Type TSource) => (s_MaxAsync__TSource__3__0 ?? (s_MaxAsync__TSource__3__0 = new Func, IComparer, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -712,7 +712,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable private static MethodInfo? s_MaxByAsync__TSource_TKey__3__0; - private static MethodInfo? MaxByAsync__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo MaxByAsync__TSource_TKey__3__0(Type TSource, Type TKey) => (s_MaxByAsync__TSource_TKey__3__0 ?? (s_MaxByAsync__TSource_TKey__3__0 = new Func, Expression>>, CancellationToken, ValueTask>>(MaxByAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -728,7 +728,7 @@ public static ValueTask> MaxByAsync(this IAsyncQue private static MethodInfo? s_MaxByAsync__TSource_TKey__3__1; - private static MethodInfo? MaxByAsync__TSource_TKey__3__1(Type TSource, Type TKey) => + private static MethodInfo MaxByAsync__TSource_TKey__3__1(Type TSource, Type TKey) => (s_MaxByAsync__TSource_TKey__3__1 ?? (s_MaxByAsync__TSource_TKey__3__1 = new Func, Expression>, CancellationToken, ValueTask>>(MaxByAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -744,7 +744,7 @@ public static ValueTask> MaxByAsync(this IAsyncQue private static MethodInfo? s_MaxByAsync__TSource_TKey__3__2; - private static MethodInfo? MaxByAsync__TSource_TKey__3__2(Type TSource, Type TKey) => + private static MethodInfo MaxByAsync__TSource_TKey__3__2(Type TSource, Type TKey) => (s_MaxByAsync__TSource_TKey__3__2 ?? (s_MaxByAsync__TSource_TKey__3__2 = new Func, Expression>>, CancellationToken, ValueTask>>(MaxByAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -760,7 +760,7 @@ public static ValueTask> MaxByAsync(this IAsyncQue private static MethodInfo? s_MaxByAsync__TSource_TKey__4__0; - private static MethodInfo? MaxByAsync__TSource_TKey__4__0(Type TSource, Type TKey) => + private static MethodInfo MaxByAsync__TSource_TKey__4__0(Type TSource, Type TKey) => (s_MaxByAsync__TSource_TKey__4__0 ?? (s_MaxByAsync__TSource_TKey__4__0 = new Func, Expression>>, IComparer, CancellationToken, ValueTask>>(MaxByAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -776,7 +776,7 @@ public static ValueTask> MaxByAsync(this IAsyncQue private static MethodInfo? s_MaxByAsync__TSource_TKey__4__1; - private static MethodInfo? MaxByAsync__TSource_TKey__4__1(Type TSource, Type TKey) => + private static MethodInfo MaxByAsync__TSource_TKey__4__1(Type TSource, Type TKey) => (s_MaxByAsync__TSource_TKey__4__1 ?? (s_MaxByAsync__TSource_TKey__4__1 = new Func, Expression>, IComparer, CancellationToken, ValueTask>>(MaxByAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -792,7 +792,7 @@ public static ValueTask> MaxByAsync(this IAsyncQue private static MethodInfo? s_MaxByAsync__TSource_TKey__4__2; - private static MethodInfo? MaxByAsync__TSource_TKey__4__2(Type TSource, Type TKey) => + private static MethodInfo MaxByAsync__TSource_TKey__4__2(Type TSource, Type TKey) => (s_MaxByAsync__TSource_TKey__4__2 ?? (s_MaxByAsync__TSource_TKey__4__2 = new Func, Expression>>, IComparer, CancellationToken, ValueTask>>(MaxByAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -808,7 +808,7 @@ public static ValueTask> MaxByAsync(this IAsyncQue private static MethodInfo? s_Merge__TSource__1__0; - private static MethodInfo? Merge__TSource__1__0(Type TSource) => + private static MethodInfo Merge__TSource__1__0(Type TSource) => (s_Merge__TSource__1__0 ?? (s_Merge__TSource__1__0 = new Func>, IAsyncQueryable>(Merge).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -822,7 +822,7 @@ public static IAsyncQueryable Merge(this IAsyncQueryable + private static MethodInfo MinAsync__TSource__3__0(Type TSource) => (s_MinAsync__TSource__3__0 ?? (s_MinAsync__TSource__3__0 = new Func, IComparer, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -836,7 +836,7 @@ public static ValueTask MinAsync(this IAsyncQueryable private static MethodInfo? s_MinByAsync__TSource_TKey__3__0; - private static MethodInfo? MinByAsync__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo MinByAsync__TSource_TKey__3__0(Type TSource, Type TKey) => (s_MinByAsync__TSource_TKey__3__0 ?? (s_MinByAsync__TSource_TKey__3__0 = new Func, Expression>>, CancellationToken, ValueTask>>(MinByAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -852,7 +852,7 @@ public static ValueTask> MinByAsync(this IAsyncQue private static MethodInfo? s_MinByAsync__TSource_TKey__3__1; - private static MethodInfo? MinByAsync__TSource_TKey__3__1(Type TSource, Type TKey) => + private static MethodInfo MinByAsync__TSource_TKey__3__1(Type TSource, Type TKey) => (s_MinByAsync__TSource_TKey__3__1 ?? (s_MinByAsync__TSource_TKey__3__1 = new Func, Expression>, CancellationToken, ValueTask>>(MinByAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -868,7 +868,7 @@ public static ValueTask> MinByAsync(this IAsyncQue private static MethodInfo? s_MinByAsync__TSource_TKey__3__2; - private static MethodInfo? MinByAsync__TSource_TKey__3__2(Type TSource, Type TKey) => + private static MethodInfo MinByAsync__TSource_TKey__3__2(Type TSource, Type TKey) => (s_MinByAsync__TSource_TKey__3__2 ?? (s_MinByAsync__TSource_TKey__3__2 = new Func, Expression>>, CancellationToken, ValueTask>>(MinByAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -884,7 +884,7 @@ public static ValueTask> MinByAsync(this IAsyncQue private static MethodInfo? s_MinByAsync__TSource_TKey__4__0; - private static MethodInfo? MinByAsync__TSource_TKey__4__0(Type TSource, Type TKey) => + private static MethodInfo MinByAsync__TSource_TKey__4__0(Type TSource, Type TKey) => (s_MinByAsync__TSource_TKey__4__0 ?? (s_MinByAsync__TSource_TKey__4__0 = new Func, Expression>>, IComparer, CancellationToken, ValueTask>>(MinByAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -900,7 +900,7 @@ public static ValueTask> MinByAsync(this IAsyncQue private static MethodInfo? s_MinByAsync__TSource_TKey__4__1; - private static MethodInfo? MinByAsync__TSource_TKey__4__1(Type TSource, Type TKey) => + private static MethodInfo MinByAsync__TSource_TKey__4__1(Type TSource, Type TKey) => (s_MinByAsync__TSource_TKey__4__1 ?? (s_MinByAsync__TSource_TKey__4__1 = new Func, Expression>, IComparer, CancellationToken, ValueTask>>(MinByAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -916,7 +916,7 @@ public static ValueTask> MinByAsync(this IAsyncQue private static MethodInfo? s_MinByAsync__TSource_TKey__4__2; - private static MethodInfo? MinByAsync__TSource_TKey__4__2(Type TSource, Type TKey) => + private static MethodInfo MinByAsync__TSource_TKey__4__2(Type TSource, Type TKey) => (s_MinByAsync__TSource_TKey__4__2 ?? (s_MinByAsync__TSource_TKey__4__2 = new Func, Expression>>, IComparer, CancellationToken, ValueTask>>(MinByAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -932,7 +932,7 @@ public static ValueTask> MinByAsync(this IAsyncQue private static MethodInfo? s_OnErrorResumeNext__TSource__2__0; - private static MethodInfo? OnErrorResumeNext__TSource__2__0(Type TSource) => + private static MethodInfo OnErrorResumeNext__TSource__2__0(Type TSource) => (s_OnErrorResumeNext__TSource__2__0 ?? (s_OnErrorResumeNext__TSource__2__0 = new Func, IAsyncEnumerable, IAsyncQueryable>(OnErrorResumeNext).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -948,7 +948,7 @@ public static IAsyncQueryable OnErrorResumeNext(this IAsyncQue private static MethodInfo? s_Repeat__TSource__1__0; - private static MethodInfo? Repeat__TSource__1__0(Type TSource) => + private static MethodInfo Repeat__TSource__1__0(Type TSource) => (s_Repeat__TSource__1__0 ?? (s_Repeat__TSource__1__0 = new Func, IAsyncQueryable>(Repeat).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -962,7 +962,7 @@ public static IAsyncQueryable Repeat(this IAsyncQueryable + private static MethodInfo Repeat__TSource__2__0(Type TSource) => (s_Repeat__TSource__2__0 ?? (s_Repeat__TSource__2__0 = new Func, int, IAsyncQueryable>(Repeat).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -976,7 +976,7 @@ public static IAsyncQueryable Repeat(this IAsyncQueryable + private static MethodInfo Retry__TSource__1__0(Type TSource) => (s_Retry__TSource__1__0 ?? (s_Retry__TSource__1__0 = new Func, IAsyncQueryable>(Retry).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -990,7 +990,7 @@ public static IAsyncQueryable Retry(this IAsyncQueryable + private static MethodInfo Retry__TSource__2__0(Type TSource) => (s_Retry__TSource__2__0 ?? (s_Retry__TSource__2__0 = new Func, int, IAsyncQueryable>(Retry).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1004,7 +1004,7 @@ public static IAsyncQueryable Retry(this IAsyncQueryable + private static MethodInfo Scan__TSource__2__0(Type TSource) => (s_Scan__TSource__2__0 ?? (s_Scan__TSource__2__0 = new Func, Expression>>, IAsyncQueryable>(Scan).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1020,7 +1020,7 @@ public static IAsyncQueryable Scan(this IAsyncQueryable + private static MethodInfo Scan__TSource__2__1(Type TSource) => (s_Scan__TSource__2__1 ?? (s_Scan__TSource__2__1 = new Func, Expression>, IAsyncQueryable>(Scan).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1036,7 +1036,7 @@ public static IAsyncQueryable Scan(this IAsyncQueryable + private static MethodInfo Scan__TSource__2__2(Type TSource) => (s_Scan__TSource__2__2 ?? (s_Scan__TSource__2__2 = new Func, Expression>>, IAsyncQueryable>(Scan).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1052,7 +1052,7 @@ public static IAsyncQueryable Scan(this IAsyncQueryable + private static MethodInfo Scan__TSource_TAccumulate__3__0(Type TSource, Type TAccumulate) => (s_Scan__TSource_TAccumulate__3__0 ?? (s_Scan__TSource_TAccumulate__3__0 = new Func, object, Expression>>, IAsyncQueryable>(Scan).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TAccumulate); @@ -1068,7 +1068,7 @@ public static IAsyncQueryable Scan(this IAsyn private static MethodInfo? s_Scan__TSource_TAccumulate__3__1; - private static MethodInfo? Scan__TSource_TAccumulate__3__1(Type TSource, Type TAccumulate) => + private static MethodInfo Scan__TSource_TAccumulate__3__1(Type TSource, Type TAccumulate) => (s_Scan__TSource_TAccumulate__3__1 ?? (s_Scan__TSource_TAccumulate__3__1 = new Func, object, Expression>, IAsyncQueryable>(Scan).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TAccumulate); @@ -1084,7 +1084,7 @@ public static IAsyncQueryable Scan(this IAsyn private static MethodInfo? s_Scan__TSource_TAccumulate__3__2; - private static MethodInfo? Scan__TSource_TAccumulate__3__2(Type TSource, Type TAccumulate) => + private static MethodInfo Scan__TSource_TAccumulate__3__2(Type TSource, Type TAccumulate) => (s_Scan__TSource_TAccumulate__3__2 ?? (s_Scan__TSource_TAccumulate__3__2 = new Func, object, Expression>>, IAsyncQueryable>(Scan).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TAccumulate); @@ -1100,7 +1100,7 @@ public static IAsyncQueryable Scan(this IAsyn private static MethodInfo? s_SelectMany__TSource_TOther__2__0; - private static MethodInfo? SelectMany__TSource_TOther__2__0(Type TSource, Type TOther) => + private static MethodInfo SelectMany__TSource_TOther__2__0(Type TSource, Type TOther) => (s_SelectMany__TSource_TOther__2__0 ?? (s_SelectMany__TSource_TOther__2__0 = new Func, IAsyncEnumerable, IAsyncQueryable>(SelectMany).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TOther); @@ -1116,7 +1116,7 @@ public static IAsyncQueryable SelectMany(this IAsyncQue private static MethodInfo? s_StartWith__TSource__2__0; - private static MethodInfo? StartWith__TSource__2__0(Type TSource) => + private static MethodInfo StartWith__TSource__2__0(Type TSource) => (s_StartWith__TSource__2__0 ?? (s_StartWith__TSource__2__0 = new Func, object[], IAsyncQueryable>(StartWith).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1132,7 +1132,7 @@ public static IAsyncQueryable StartWith(this IAsyncQueryable + private static MethodInfo Timeout__TSource__2__0(Type TSource) => (s_Timeout__TSource__2__0 ?? (s_Timeout__TSource__2__0 = new Func, TimeSpan, IAsyncQueryable>(Timeout).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); diff --git a/Ix.NET/Source/System.Interactive.Async.Providers/System/Linq/AsyncQueryableEx.Generated.tt b/Ix.NET/Source/System.Interactive.Async.Providers/System/Linq/AsyncQueryableEx.Generated.tt index 3b1dc188eb..750ab641ef 100644 --- a/Ix.NET/Source/System.Interactive.Async.Providers/System/Linq/AsyncQueryableEx.Generated.tt +++ b/Ix.NET/Source/System.Interactive.Async.Providers/System/Linq/AsyncQueryableEx.Generated.tt @@ -3,10 +3,10 @@ // See the LICENSE file in the project root for more information. <#@ template debug="false" hostspecific="false" language="C#" #> -<#@ assembly name="$(ProjectDir)\..\System.Linq.Async\bin\$(Configuration)\net461\Microsoft.Bcl.AsyncInterfaces.dll" #> -<#@ assembly name="$(ProjectDir)\..\System.Linq.Async\bin\$(Configuration)\net461\System.Threading.Tasks.Extensions.dll" #> -<#@ assembly name="$(ProjectDir)\..\System.Linq.Async\bin\$(Configuration)\net461\System.Linq.Async.dll" #> -<#@ assembly name="$(ProjectDir)\..\System.Interactive.Async\bin\$(Configuration)\net461\System.Interactive.Async.dll" #> +<#@ assembly name="$(ProjectDir)\..\System.Linq.Async\bin\$(Configuration)\net48\Microsoft.Bcl.AsyncInterfaces.dll" #> +<#@ assembly name="$(ProjectDir)\..\System.Linq.Async\bin\$(Configuration)\net48\System.Threading.Tasks.Extensions.dll" #> +<#@ assembly name="$(ProjectDir)\..\System.Linq.Async\bin\$(Configuration)\net48\System.Linq.Async.dll" #> +<#@ assembly name="$(ProjectDir)\..\System.Interactive.Async\bin\$(Configuration)\net48\System.Interactive.Async.dll" #> <#@ output extension=".cs" #> <# var asyncEnumerableType = typeof(AsyncEnumerableEx); diff --git a/Ix.NET/Source/System.Interactive.Async.Tests/System.Interactive.Async.Tests.csproj b/Ix.NET/Source/System.Interactive.Async.Tests/System.Interactive.Async.Tests.csproj index 64e8f4db32..0cd534fdd7 100644 --- a/Ix.NET/Source/System.Interactive.Async.Tests/System.Interactive.Async.Tests.csproj +++ b/Ix.NET/Source/System.Interactive.Async.Tests/System.Interactive.Async.Tests.csproj @@ -1,8 +1,15 @@  - net48;net6.0;netcoreapp3.1 - $(NoWarn);CS0618;CS8603;CS8625 + + net48;net8.0;net6.0;netcoreapp3.1 + + + $(NoWarn);CS0618;CS8603;CS8625;CA1510;CA1822;CA1861 diff --git a/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Buffer.cs b/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Buffer.cs index 726d4d780c..e77b5565cf 100644 --- a/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Buffer.cs +++ b/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Buffer.cs @@ -31,13 +31,13 @@ public async Task Buffer1Async() var e = xs.GetAsyncEnumerator(); Assert.True(await e.MoveNextAsync()); - Assert.True(e.Current.SequenceEqual(new[] { 1, 2 })); + Assert.True(e.Current.SequenceEqual([1, 2])); Assert.True(await e.MoveNextAsync()); - Assert.True(e.Current.SequenceEqual(new[] { 3, 4 })); + Assert.True(e.Current.SequenceEqual([3, 4])); Assert.True(await e.MoveNextAsync()); - Assert.True(e.Current.SequenceEqual(new[] { 5 })); + Assert.True(e.Current.SequenceEqual([5])); Assert.False(await e.MoveNextAsync()); } @@ -50,13 +50,13 @@ public async Task Buffer2Async() var e = xs.GetAsyncEnumerator(); Assert.True(await e.MoveNextAsync()); - Assert.True(e.Current.SequenceEqual(new[] { 1, 2, 3 })); + Assert.True(e.Current.SequenceEqual([1, 2, 3])); Assert.True(await e.MoveNextAsync()); - Assert.True(e.Current.SequenceEqual(new[] { 3, 4, 5 })); + Assert.True(e.Current.SequenceEqual([3, 4, 5])); Assert.True(await e.MoveNextAsync()); - Assert.True(e.Current.SequenceEqual(new[] { 5 })); + Assert.True(e.Current.SequenceEqual([5])); Assert.False(await e.MoveNextAsync()); } @@ -69,10 +69,10 @@ public async Task Buffer3Async() var e = xs.GetAsyncEnumerator(); Assert.True(await e.MoveNextAsync()); - Assert.True(e.Current.SequenceEqual(new[] { 1, 2 })); + Assert.True(e.Current.SequenceEqual([1, 2])); Assert.True(await e.MoveNextAsync()); - Assert.True(e.Current.SequenceEqual(new[] { 4, 5 })); + Assert.True(e.Current.SequenceEqual([4, 5])); Assert.False(await e.MoveNextAsync()); } diff --git a/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/MaxBy.cs b/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/MaxBy.cs index a819df9efc..68539d8a29 100644 --- a/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/MaxBy.cs +++ b/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/MaxBy.cs @@ -35,13 +35,13 @@ public async Task MaxBy1Async() var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MaxByAsync(x => x / 2); var res = await xs; - Assert.True(res.SequenceEqual(new[] { 7, 6 })); + Assert.True(res.SequenceEqual([7, 6])); } [Fact] public async Task MaxBy2() { - var xs = new int[0].ToAsyncEnumerable().MaxByAsync(x => x / 2); + var xs = Array.Empty().ToAsyncEnumerable().MaxByAsync(x => x / 2); await AssertThrowsAsync(xs.AsTask()); } diff --git a/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/MinBy.cs b/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/MinBy.cs index 018f3cf305..86b9ed06fa 100644 --- a/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/MinBy.cs +++ b/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/MinBy.cs @@ -35,13 +35,13 @@ public async Task MinBy1Async() var xs = new[] { 3, 5, 7, 6, 4, 2 }.ToAsyncEnumerable().MinByAsync(x => x / 2); var res = await xs; - Assert.True(res.SequenceEqual(new[] { 3, 2 })); + Assert.True(res.SequenceEqual([3, 2])); } [Fact] public async Task MinBy2Async() { - var xs = new int[0].ToAsyncEnumerable().MinByAsync(x => x / 2); + var xs = Array.Empty().ToAsyncEnumerable().MinByAsync(x => x / 2); await AssertThrowsAsync(xs.AsTask()); } diff --git a/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Never.cs b/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Never.cs index 9a2781afe7..8f90cc5ff3 100644 --- a/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Never.cs +++ b/Ix.NET/Source/System.Interactive.Async.Tests/System/Linq/Operators/Never.cs @@ -2,6 +2,10 @@ // The .NET Foundation licenses this file to you under the MIT License. // See the LICENSE file in the project root for more information. +#if NET6_0_OR_GREATER +#pragma warning disable CA2012 // Use ValueTasks correctly. These tests need to use Result to verify correct operation, so we can't avoid breaking this rule. +#endif + using System.Linq; using System.Threading; using System.Threading.Tasks; diff --git a/Ix.NET/Source/System.Interactive.Async/EmptyArray.cs b/Ix.NET/Source/System.Interactive.Async/EmptyArray.cs deleted file mode 100644 index 328b62b532..0000000000 --- a/Ix.NET/Source/System.Interactive.Async/EmptyArray.cs +++ /dev/null @@ -1,15 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT License. -// See the LICENSE file in the project root for more information. - -#if NO_ARRAY_EMPTY - -namespace System.Linq -{ - internal sealed class EmptyArray - { - public static readonly TElement[] Value = new TElement[0]; - } -} - -#endif diff --git a/Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj b/Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj index 06bddca8c8..aa02a1e922 100644 --- a/Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj +++ b/Ix.NET/Source/System.Interactive.Async/System.Interactive.Async.csproj @@ -7,6 +7,11 @@ Ix;Interactive;Extensions;Enumerable;Asynchronous + + + $(NoWarn);IDE0305 + + diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Generate.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Generate.cs index 55bb2ae65b..fd49c88b09 100644 --- a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Generate.cs +++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Generate.cs @@ -34,7 +34,7 @@ public static IAsyncEnumerable Generate(TState initial #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously return Core(initialState, condition, iterate, resultSelector); - static async IAsyncEnumerable Core(TState initialState, Func condition, Func iterate, Func resultSelector, [System.Runtime.CompilerServices.EnumeratorCancellation] CancellationToken cancellationToken = default) + static async IAsyncEnumerable Core(TState initialState, Func condition, Func iterate, Func resultSelector) { for (var state = initialState; condition(state); state = iterate(state)) { diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Merge.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Merge.cs index afdfd0282d..551a384f43 100644 --- a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Merge.cs +++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Merge.cs @@ -276,12 +276,7 @@ static async IAsyncEnumerable Core(IAsyncEnumerable[] sources, } catch (Exception ex) { - if (errors == null) - { - errors = new List(); - } - - errors.Add(ex); + (errors ??= []).Add(ex); } } @@ -292,21 +287,27 @@ static async IAsyncEnumerable Core(IAsyncEnumerable[] sources, if (errors != null) { +#if NET6_0_OR_GREATER +#pragma warning disable CA2219 // Do not raise an exception from within a finally clause +#endif throw new AggregateException(errors); +#if NET6_0_OR_GREATER +#pragma warning restore CA2219 +#endif } } } #endif - } + } - /// - /// Merges elements from all async-enumerable sequences in the given enumerable sequence into a single async-enumerable sequence. - /// - /// The type of the elements in the source sequences. - /// Enumerable sequence of async-enumerable sequences. - /// The async-enumerable sequence that merges the elements of the async-enumerable sequences. - /// is null. - public static IAsyncEnumerable Merge(this IEnumerable> sources) + /// + /// Merges elements from all async-enumerable sequences in the given enumerable sequence into a single async-enumerable sequence. + /// + /// The type of the elements in the source sequences. + /// Enumerable sequence of async-enumerable sequences. + /// The async-enumerable sequence that merges the elements of the async-enumerable sequences. + /// is null. + public static IAsyncEnumerable Merge(this IEnumerable> sources) { if (sources == null) throw Error.ArgumentNull(nameof(sources)); diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/MinBy.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/MinBy.cs index 3dd8ba25d6..1983e05da5 100644 --- a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/MinBy.cs +++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/MinBy.cs @@ -192,7 +192,7 @@ private static async ValueTask> ExtremaBy(IAsyncEn } else if (cmp > 0) { - result = new List { cur }; + result = [cur]; resKey = key; } } @@ -227,7 +227,7 @@ private static async ValueTask> ExtremaBy(IAsyncEn } else if (cmp > 0) { - result = new List { cur }; + result = [cur]; resKey = key; } } @@ -263,7 +263,7 @@ private static async ValueTask> ExtremaBy(IAsyncEn } else if (cmp > 0) { - result = new List { cur }; + result = [cur]; resKey = key; } } diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Never.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Never.cs index cb51d92322..0f571ac4d6 100644 --- a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Never.cs +++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Never.cs @@ -19,7 +19,7 @@ public static partial class AsyncEnumerableEx private sealed class NeverAsyncEnumerable : IAsyncEnumerable { - internal static readonly NeverAsyncEnumerable Instance = new NeverAsyncEnumerable(); + internal static readonly NeverAsyncEnumerable Instance = new(); public IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken) { @@ -28,15 +28,13 @@ public IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellatio return new NeverAsyncEnumerator(cancellationToken); } - private sealed class NeverAsyncEnumerator : IAsyncEnumerator + private sealed class NeverAsyncEnumerator(CancellationToken token) : IAsyncEnumerator { - private readonly CancellationToken _token; + private readonly CancellationToken _token = token; private CancellationTokenRegistration _registration; private bool _once; - public NeverAsyncEnumerator(CancellationToken token) => _token = token; - public TValue Current => throw new InvalidOperationException(); public ValueTask DisposeAsync() @@ -54,7 +52,7 @@ public ValueTask MoveNextAsync() _once = true; var task = new TaskCompletionSource(); - _registration = _token.Register(state => ((TaskCompletionSource)state).TrySetCanceled(_token), task); + _registration = _token.Register(state => ((TaskCompletionSource)state!).TrySetCanceled(_token), task); return new ValueTask(task.Task); } } diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Return.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Return.cs index 8773f18e2d..3c1c5c514a 100644 --- a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Return.cs +++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Return.cs @@ -33,11 +33,11 @@ public IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellatio return new ReturnEnumerator(_value); } - public ValueTask GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new ValueTask(1); + public ValueTask GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new(1); - public ValueTask ToArrayAsync(CancellationToken cancellationToken) => new ValueTask(new[] { _value }); + public ValueTask ToArrayAsync(CancellationToken cancellationToken) => new([_value]); - public ValueTask> ToListAsync(CancellationToken cancellationToken) => new ValueTask>(new List(1) { _value }); + public ValueTask> ToListAsync(CancellationToken cancellationToken) => new([_value]); private sealed class ReturnEnumerator : IAsyncEnumerator { diff --git a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Timeout.cs b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Timeout.cs index 53a0dd626e..5c621bc891 100644 --- a/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Timeout.cs +++ b/Ix.NET/Source/System.Interactive.Async/System/Linq/Operators/Timeout.cs @@ -105,7 +105,13 @@ protected override async ValueTask MoveNextCore() goto case AsyncIteratorState.Iterating; case AsyncIteratorState.Iterating: +#if NET6_0_OR_GREATER +#pragma warning disable CA2012 // Always await ValueTasks immediately; this is deliberate advanced usage +#endif var moveNext = _enumerator!.MoveNextAsync(); +#if NET6_0_OR_GREATER +#pragma warning restore CA2012 +#endif if (!moveNext.IsCompleted) { diff --git a/Ix.NET/Source/System.Interactive.Providers/System.Interactive.Providers.csproj b/Ix.NET/Source/System.Interactive.Providers/System.Interactive.Providers.csproj index 9f17be765d..09eba524d1 100644 --- a/Ix.NET/Source/System.Interactive.Providers/System.Interactive.Providers.csproj +++ b/Ix.NET/Source/System.Interactive.Providers/System.Interactive.Providers.csproj @@ -1,4 +1,4 @@ - + Interactive Extensions Providers Library used to build query providers and express queries over enumerable sequences. @@ -13,7 +13,32 @@ - + + + + + + + + + + $(NoWarn);NU5128;NU5131 + + diff --git a/Ix.NET/Source/System.Interactive.Providers/System/Linq/QueryableEx.cs b/Ix.NET/Source/System.Interactive.Providers/System/Linq/QueryableEx.cs index 18417747b1..03eb0186bd 100644 --- a/Ix.NET/Source/System.Interactive.Providers/System/Linq/QueryableEx.cs +++ b/Ix.NET/Source/System.Interactive.Providers/System/Linq/QueryableEx.cs @@ -23,7 +23,7 @@ private sealed class QueryProviderShim : IQueryProvider { public IQueryable CreateQuery(Expression expression) { - var provider = new TElement[0].AsQueryable().Provider; + var provider = Array.Empty().AsQueryable().Provider; var res = Redir(expression); return provider.CreateQuery(res); } @@ -35,7 +35,7 @@ public IQueryable CreateQuery(Expression expression) public TResult Execute(Expression expression) { - var provider = new TResult[0].AsQueryable().Provider; + var provider = Array.Empty().AsQueryable().Provider; var res = Redir(expression); return provider.Execute(res); } diff --git a/Ix.NET/Source/System.Interactive.Tests/System.Interactive.Tests.csproj b/Ix.NET/Source/System.Interactive.Tests/System.Interactive.Tests.csproj index 7281ed0908..32858aa6c0 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System.Interactive.Tests.csproj +++ b/Ix.NET/Source/System.Interactive.Tests/System.Interactive.Tests.csproj @@ -1,8 +1,14 @@  - net48;net6.0;netcoreapp3.1 - $(NoWarn);CS0618;CS8603;CS8625 + + net48;net8.0;net6.0;netcoreapp3.1 + + + $(NoWarn);CS0618;CS8603;CS8625;CA1822;CA1861 diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Buffer.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Buffer.cs index e4e5493060..76118775b1 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Buffer.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Buffer.cs @@ -15,9 +15,9 @@ public void Buffer_Arguments() { AssertThrows(() => EnumerableEx.Buffer(null, 5)); AssertThrows(() => EnumerableEx.Buffer(null, 5, 3)); - AssertThrows(() => EnumerableEx.Buffer(new[] { 1 }, 0)); - AssertThrows(() => EnumerableEx.Buffer(new[] { 1 }, 5, 0)); - AssertThrows(() => EnumerableEx.Buffer(new[] { 1 }, 0, 3)); + AssertThrows(() => EnumerableEx.Buffer([1], 0)); + AssertThrows(() => EnumerableEx.Buffer([1], 5, 0)); + AssertThrows(() => EnumerableEx.Buffer([1], 0, 3)); } [Fact] @@ -28,10 +28,10 @@ public void Buffer1() var res = rng.Buffer(3).ToList(); Assert.Equal(4, res.Count); - Assert.True(res[0].SequenceEqual(new[] { 0, 1, 2 })); - Assert.True(res[1].SequenceEqual(new[] { 3, 4, 5 })); - Assert.True(res[2].SequenceEqual(new[] { 6, 7, 8 })); - Assert.True(res[3].SequenceEqual(new[] { 9 })); + Assert.True(res[0].SequenceEqual([0, 1, 2])); + Assert.True(res[1].SequenceEqual([3, 4, 5])); + Assert.True(res[2].SequenceEqual([6, 7, 8])); + Assert.True(res[3].SequenceEqual([9])); } [Fact] @@ -42,8 +42,8 @@ public void Buffer2() var res = rng.Buffer(5).ToList(); Assert.Equal(2, res.Count); - Assert.True(res[0].SequenceEqual(new[] { 0, 1, 2, 3, 4 })); - Assert.True(res[1].SequenceEqual(new[] { 5, 6, 7, 8, 9 })); + Assert.True(res[0].SequenceEqual([0, 1, 2, 3, 4])); + Assert.True(res[1].SequenceEqual([5, 6, 7, 8, 9])); } [Fact] @@ -63,11 +63,11 @@ public void Buffer4() var res = rng.Buffer(3, 2).ToList(); Assert.Equal(5, res.Count); - Assert.True(res[0].SequenceEqual(new[] { 0, 1, 2 })); - Assert.True(res[1].SequenceEqual(new[] { 2, 3, 4 })); - Assert.True(res[2].SequenceEqual(new[] { 4, 5, 6 })); - Assert.True(res[3].SequenceEqual(new[] { 6, 7, 8 })); - Assert.True(res[4].SequenceEqual(new[] { 8, 9 })); + Assert.True(res[0].SequenceEqual([0, 1, 2])); + Assert.True(res[1].SequenceEqual([2, 3, 4])); + Assert.True(res[2].SequenceEqual([4, 5, 6])); + Assert.True(res[3].SequenceEqual([6, 7, 8])); + Assert.True(res[4].SequenceEqual([8, 9])); } [Fact] @@ -78,9 +78,9 @@ public void Buffer5() var res = rng.Buffer(3, 4).ToList(); Assert.Equal(3, res.Count); - Assert.True(res[0].SequenceEqual(new[] { 0, 1, 2 })); - Assert.True(res[1].SequenceEqual(new[] { 4, 5, 6 })); - Assert.True(res[2].SequenceEqual(new[] { 8, 9 })); + Assert.True(res[0].SequenceEqual([0, 1, 2])); + Assert.True(res[1].SequenceEqual([4, 5, 6])); + Assert.True(res[2].SequenceEqual([8, 9])); } } } diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Case.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Case.cs index 8d4131e362..76e62127d6 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Case.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Case.cs @@ -16,8 +16,8 @@ public void Case_Arguments() { AssertThrows(() => EnumerableEx.Case(null, new Dictionary>())); AssertThrows(() => EnumerableEx.Case(() => 1, null)); - AssertThrows(() => EnumerableEx.Case(null, new Dictionary>(), new[] { 1 })); - AssertThrows(() => EnumerableEx.Case(() => 1, null, new[] { 1 })); + AssertThrows(() => EnumerableEx.Case(null, new Dictionary>(), [1])); + AssertThrows(() => EnumerableEx.Case(() => 1, null, [1])); AssertThrows(() => EnumerableEx.Case(() => 1, new Dictionary>(), null)); } @@ -64,7 +64,7 @@ public void Case2() { 1, new[] { 'b' } }, { 2, new[] { 'c' } }, { 3, EnumerableEx.Defer(() => new[] { d }) }, - }, new[] { 'z' }); + }, ['z']); Assert.Equal('b', res.Single()); Assert.Equal('b', res.Single()); diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Create.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Create.cs index 44bc389505..6b4a722edb 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Create.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Create.cs @@ -16,7 +16,7 @@ public class Create : Tests [Fact] public void Create_Arguments() { - AssertThrows(() => EnumerableEx.Create(default(Func>))); + AssertThrows(() => EnumerableEx.Create(default)); } [Fact] diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Distinct.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Distinct.cs index cc692a4198..cf340c7a22 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Distinct.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Distinct.cs @@ -15,10 +15,10 @@ public class Distinct : Tests public void Distinct_Arguments() { AssertThrows(() => EnumerableEx.Distinct(null, _ => _)); - AssertThrows(() => EnumerableEx.Distinct(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.Distinct([1], null)); AssertThrows(() => EnumerableEx.Distinct(null, _ => _, EqualityComparer.Default)); - AssertThrows(() => EnumerableEx.Distinct(new[] { 1 }, null, EqualityComparer.Default)); - AssertThrows(() => EnumerableEx.Distinct(new[] { 1 }, _ => _, null)); + AssertThrows(() => EnumerableEx.Distinct([1], null, EqualityComparer.Default)); + AssertThrows(() => EnumerableEx.Distinct([1], _ => _, null)); } [Fact] @@ -32,7 +32,7 @@ public void Distinct1() public void Distinct2() { var res = Enumerable.Range(0, 10).Distinct(x => x % 5, new MyEqualityComparer()).ToList(); - Assert.True(Enumerable.SequenceEqual(res, new[] { 0, 1 })); + Assert.True(Enumerable.SequenceEqual(res, [0, 1])); } private sealed class MyEqualityComparer : IEqualityComparer diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/DistinctUntilChanged.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/DistinctUntilChanged.cs index 6c6e79c199..7ad5f6a2ea 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/DistinctUntilChanged.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/DistinctUntilChanged.cs @@ -16,26 +16,26 @@ public void DistinctUntilChanged_Arguments() { AssertThrows(() => EnumerableEx.DistinctUntilChanged(null)); AssertThrows(() => EnumerableEx.DistinctUntilChanged(null, EqualityComparer.Default)); - AssertThrows(() => EnumerableEx.DistinctUntilChanged(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.DistinctUntilChanged([1], null)); AssertThrows(() => EnumerableEx.DistinctUntilChanged(null, _ => _)); - AssertThrows(() => EnumerableEx.DistinctUntilChanged(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.DistinctUntilChanged([1], null)); AssertThrows(() => EnumerableEx.DistinctUntilChanged(null, _ => _, EqualityComparer.Default)); - AssertThrows(() => EnumerableEx.DistinctUntilChanged(new[] { 1 }, null, EqualityComparer.Default)); - AssertThrows(() => EnumerableEx.DistinctUntilChanged(new[] { 1 }, _ => _, null)); + AssertThrows(() => EnumerableEx.DistinctUntilChanged([1], null, EqualityComparer.Default)); + AssertThrows(() => EnumerableEx.DistinctUntilChanged([1], _ => _, null)); } [Fact] public void DistinctUntilChanged1() { var res = new[] { 1, 2, 2, 3, 3, 3, 2, 2, 1 }.DistinctUntilChanged().ToList(); - Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 2, 1 })); + Assert.True(Enumerable.SequenceEqual(res, [1, 2, 3, 2, 1])); } [Fact] public void DistinctUntilChanged2() { var res = new[] { 1, 1, 2, 3, 4, 5, 5, 6, 7 }.DistinctUntilChanged(x => x / 2).ToList(); - Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 4, 6 })); + Assert.True(Enumerable.SequenceEqual(res, [1, 2, 4, 6])); } } } diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Do.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Do.cs index b4b035a8af..6c7b425404 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Do.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Do.cs @@ -17,16 +17,16 @@ public void Do_Arguments() AssertThrows(() => EnumerableEx.Do(null, _ => { }, () => { })); AssertThrows(() => EnumerableEx.Do(null, _ => { }, _ => { })); AssertThrows(() => EnumerableEx.Do(null, _ => { }, _ => { }, () => { })); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(Action))); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(Action), () => { })); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, _ => { }, default(Action))); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(Action), _ => { }, () => { })); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, _ => { }, default(Action), () => { })); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, _ => { }, _ => { }, default(Action))); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(Action), _ => { })); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, _ => { }, default(Action))); + AssertThrows(() => EnumerableEx.Do([1], default(Action))); + AssertThrows(() => EnumerableEx.Do([1], default, () => { })); + AssertThrows(() => EnumerableEx.Do([1], _ => { }, default(Action))); + AssertThrows(() => EnumerableEx.Do([1], default, _ => { }, () => { })); + AssertThrows(() => EnumerableEx.Do([1], _ => { }, default, () => { })); + AssertThrows(() => EnumerableEx.Do([1], _ => { }, _ => { }, default)); + AssertThrows(() => EnumerableEx.Do([1], default, _ => { })); + AssertThrows(() => EnumerableEx.Do([1], _ => { }, default(Action))); AssertThrows(() => EnumerableEx.Do(null, new MyObserver())); - AssertThrows(() => EnumerableEx.Do(new[] { 1 }, default(IObserver))); + AssertThrows(() => EnumerableEx.Do([1], default(IObserver))); } [Fact] diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/DoWhile.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/DoWhile.cs index 001bfb445c..c043daee82 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/DoWhile.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/DoWhile.cs @@ -13,7 +13,7 @@ public class DoWhile : Tests [Fact] public void DoWhile_Arguments() { - AssertThrows(() => EnumerableEx.DoWhile(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.DoWhile([1], null)); AssertThrows(() => EnumerableEx.DoWhile(null, () => true)); } @@ -22,7 +22,7 @@ public void DoWhile1() { var x = 5; var res = EnumerableEx.DoWhile(EnumerableEx.Defer(() => new[] { x }).Do(_ => x--), () => x > 0).ToList(); - Assert.True(Enumerable.SequenceEqual(res, new[] { 5, 4, 3, 2, 1 })); + Assert.True(Enumerable.SequenceEqual(res, [5, 4, 3, 2, 1])); } [Fact] @@ -30,7 +30,7 @@ public void DoWhile2() { var x = 0; var res = EnumerableEx.DoWhile(EnumerableEx.Defer(() => new[] { x }).Do(_ => x--), () => x > 0).ToList(); - Assert.True(Enumerable.SequenceEqual(res, new[] { 0 })); + Assert.True(Enumerable.SequenceEqual(res, [0])); } } } diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Expand.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Expand.cs index 91b14a1c93..76157b145d 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Expand.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Expand.cs @@ -13,14 +13,14 @@ public class Expand : Tests [Fact] public void Expand_Arguments() { - AssertThrows(() => EnumerableEx.Expand(null, _ => new[] { _ })); - AssertThrows(() => EnumerableEx.Expand(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.Expand(null, _ => [_])); + AssertThrows(() => EnumerableEx.Expand([1], null)); } [Fact] public void Expand1() { - var res = new[] { 0 }.Expand(x => new[] { x + 1 }).Take(10).ToList(); + var res = new[] { 0 }.Expand(x => [x + 1]).Take(10).ToList(); Assert.True(Enumerable.SequenceEqual(res, Enumerable.Range(0, 10))); } diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Finally.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Finally.cs index 08c7287e19..459f60090e 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Finally.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Finally.cs @@ -14,7 +14,7 @@ public class Finally : Tests public void Finally_Arguments() { AssertThrows(() => EnumerableEx.Finally(null, () => { })); - AssertThrows(() => EnumerableEx.Finally(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.Finally([1], null)); } [Fact] diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/For.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/For.cs index 7109c81383..405dcb0d44 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/For.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/For.cs @@ -13,15 +13,15 @@ public class For : Tests [Fact] public void For_Arguments() { - AssertThrows(() => EnumerableEx.For(null, x => new[] { 1 })); - AssertThrows(() => EnumerableEx.For(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.For(null, x => [1])); + AssertThrows(() => EnumerableEx.For([1], null)); } [Fact] public void For1() { var res = EnumerableEx.For(new[] { 1, 2, 3 }, x => Enumerable.Range(0, x)).ToList(); - Assert.True(res.SequenceEqual(new[] { 0, 0, 1, 0, 1, 2 })); + Assert.True(res.SequenceEqual([0, 0, 1, 0, 1, 2])); } } } diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/ForEach.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/ForEach.cs index 6301ec3602..cb98b4656b 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/ForEach.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/ForEach.cs @@ -14,9 +14,9 @@ public class ForEach : Tests public void ForEach_Arguments() { AssertThrows(() => EnumerableEx.ForEach(null, x => { })); - AssertThrows(() => EnumerableEx.ForEach(new[] { 1 }, default(Action))); + AssertThrows(() => EnumerableEx.ForEach([1], default(Action))); AssertThrows(() => EnumerableEx.ForEach(null, (x, i) => { })); - AssertThrows(() => EnumerableEx.ForEach(new[] { 1 }, default(Action))); + AssertThrows(() => EnumerableEx.ForEach([1], default(Action))); } [Fact] diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Generate.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Generate.cs index b4f8482913..af85672afa 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Generate.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Generate.cs @@ -22,7 +22,7 @@ public void Generate_Arguments() public void Generate1() { var res = EnumerableEx.Generate(0, x => x < 5, x => x + 1, x => x * x).ToList(); - Assert.True(Enumerable.SequenceEqual(res, new[] { 0, 1, 4, 9, 16 })); + Assert.True(Enumerable.SequenceEqual(res, [0, 1, 4, 9, 16])); } } } diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/If.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/If.cs index 4bddac19af..9c7c6bfbfb 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/If.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/If.cs @@ -13,18 +13,18 @@ public class If : Tests [Fact] public void If_Arguments() { - AssertThrows(() => EnumerableEx.If(null, new[] { 1 })); + AssertThrows(() => EnumerableEx.If(null, [1])); AssertThrows(() => EnumerableEx.If(() => true, null)); - AssertThrows(() => EnumerableEx.If(null, new[] { 1 }, new[] { 1 })); - AssertThrows(() => EnumerableEx.If(() => true, null, new[] { 1 })); - AssertThrows(() => EnumerableEx.If(() => true, new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.If(null, [1], [1])); + AssertThrows(() => EnumerableEx.If(() => true, null, [1])); + AssertThrows(() => EnumerableEx.If(() => true, [1], null)); } [Fact] public void If1() { var x = 5; - var res = EnumerableEx.If(() => x > 0, new[] { +1 }, new[] { -1 }); + var res = EnumerableEx.If(() => x > 0, [+1], [-1]); Assert.Equal(+1, res.Single()); diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/MaxBy.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/MaxBy.cs index 6c56222c44..0fff89dd1a 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/MaxBy.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/MaxBy.cs @@ -16,17 +16,17 @@ public class MaxBy : Tests public void MaxBy_Arguments() { AssertThrows(() => EnumerableEx.MaxBy(null, (int x) => x)); - AssertThrows(() => EnumerableEx.MaxBy(new[] { 1 }, default(Func))); + AssertThrows(() => EnumerableEx.MaxBy([1], default(Func))); AssertThrows(() => EnumerableEx.MaxBy(null, (int x) => x, Comparer.Default)); - AssertThrows(() => EnumerableEx.MaxBy(new[] { 1 }, default(Func), Comparer.Default)); - AssertThrows(() => EnumerableEx.MaxBy(new[] { 1 }, (int x) => x, null)); + AssertThrows(() => EnumerableEx.MaxBy([1], default, Comparer.Default)); + AssertThrows(() => EnumerableEx.MaxBy([1], (int x) => x, null)); } [Fact] public void MaxBy1() { var res = new[] { 2, 5, 0, 7, 4, 3, 6, 2, 1 }.MaxBy(x => x % 3); - Assert.True(res.SequenceEqual(new[] { 2, 5, 2 })); + Assert.True(res.SequenceEqual([2, 5, 2])); } [Fact] diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Memoize.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Memoize.cs index 7aa67553c1..4342edf997 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Memoize.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Memoize.cs @@ -22,8 +22,8 @@ public void Memoize_Arguments() public void MemoizeLimited_Arguments() { AssertThrows(() => EnumerableEx.Memoize(null, 2)); - AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, 0)); - AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, -1)); + AssertThrows(() => EnumerableEx.Memoize([1], 0)); + AssertThrows(() => EnumerableEx.Memoize([1], -1)); } [Fact] @@ -227,7 +227,7 @@ public void Memoize9() var e1 = ((IEnumerable)rng).GetEnumerator(); Assert.True(e1.MoveNext()); - Assert.Equal(0, (int)e1.Current); + Assert.Equal(0, (int)e1.Current!); } [Fact] @@ -251,7 +251,7 @@ private static IEnumerable Tick(Action t) public void MemoizeLambda_Arguments() { AssertThrows(() => EnumerableEx.Memoize(null, xs => xs)); - AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.Memoize([1], null)); } [Fact] @@ -267,9 +267,9 @@ public void MemoizeLambda() public void MemoizeLimitedLambda_Arguments() { AssertThrows(() => EnumerableEx.Memoize(null, 2, xs => xs)); - AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, 2, null)); - AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, 0, xs => xs)); - AssertThrows(() => EnumerableEx.Memoize(new[] { 1 }, -1, xs => xs)); + AssertThrows(() => EnumerableEx.Memoize([1], 2, null)); + AssertThrows(() => EnumerableEx.Memoize([1], 0, xs => xs)); + AssertThrows(() => EnumerableEx.Memoize([1], -1, xs => xs)); } [Fact] @@ -281,12 +281,12 @@ public void MemoizeLimitedLambda() Assert.Equal(4, n); } - private static readonly Random s_rand = new Random(); + private static readonly Random RandSource = new(); private static IEnumerable Rand() { while (true) - yield return s_rand.Next(); + yield return RandSource.Next(); } private sealed class MyException : Exception diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/MinBy.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/MinBy.cs index 2b19f38e19..9c048709b5 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/MinBy.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/MinBy.cs @@ -16,17 +16,17 @@ public class MinBy : Tests public void MinBy_Arguments() { AssertThrows(() => EnumerableEx.MinBy(null, (int x) => x)); - AssertThrows(() => EnumerableEx.MinBy(new[] { 1 }, default(Func))); + AssertThrows(() => EnumerableEx.MinBy([1], default(Func))); AssertThrows(() => EnumerableEx.MinBy(null, (int x) => x, Comparer.Default)); - AssertThrows(() => EnumerableEx.MinBy(new[] { 1 }, default(Func), Comparer.Default)); - AssertThrows(() => EnumerableEx.MinBy(new[] { 1 }, (int x) => x, null)); + AssertThrows(() => EnumerableEx.MinBy([1], default, Comparer.Default)); + AssertThrows(() => EnumerableEx.MinBy([1], (int x) => x, null)); } [Fact] public void MinBy1() { var res = new[] { 2, 5, 0, 7, 4, 3, 6, 2, 1 }.MinBy(x => x % 3); - Assert.True(res.SequenceEqual(new[] { 0, 3, 6 })); + Assert.True(res.SequenceEqual([0, 3, 6])); } [Fact] diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/OnErrorResumeNext.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/OnErrorResumeNext.cs index af5a9ed68b..c6d764995c 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/OnErrorResumeNext.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/OnErrorResumeNext.cs @@ -14,9 +14,9 @@ public class OnErrorResumeNext : Tests [Fact] public void OnErrorResumeNext_Arguments() { - AssertThrows(() => EnumerableEx.OnErrorResumeNext(null, new[] { 1 })); - AssertThrows(() => EnumerableEx.OnErrorResumeNext(new[] { 1 }, null)); - AssertThrows(() => EnumerableEx.OnErrorResumeNext(default(IEnumerable[]))); + AssertThrows(() => EnumerableEx.OnErrorResumeNext(null, [1])); + AssertThrows(() => EnumerableEx.OnErrorResumeNext([1], null)); + AssertThrows(() => EnumerableEx.OnErrorResumeNext(default)); AssertThrows(() => EnumerableEx.OnErrorResumeNext(default(IEnumerable>))); } @@ -27,7 +27,7 @@ public void OnErrorResumeNext1() var ys = new[] { 3, 4 }; var res = xs.OnErrorResumeNext(ys); - Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 })); + Assert.True(Enumerable.SequenceEqual(res, [1, 2, 3, 4])); } [Fact] @@ -37,7 +37,7 @@ public void OnErrorResumeNext2() var ys = new[] { 3, 4 }; var res = xs.OnErrorResumeNext(ys); - Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 })); + Assert.True(Enumerable.SequenceEqual(res, [1, 2, 3, 4])); } [Fact] @@ -48,7 +48,7 @@ public void OnErrorResumeNext3() var zs = new[] { 5, 6 }; var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs); - Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 })); + Assert.True(Enumerable.SequenceEqual(res, [1, 2, 3, 4, 5, 6])); } [Fact] @@ -59,7 +59,7 @@ public void OnErrorResumeNext4() var zs = new[] { 5, 6 }; var res = EnumerableEx.OnErrorResumeNext(xs, ys, zs); - Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4, 5, 6 })); + Assert.True(Enumerable.SequenceEqual(res, [1, 2, 3, 4, 5, 6])); } [Fact] @@ -69,7 +69,7 @@ public void OnErrorResumeNext5() var ys = new[] { 3, 4 }; var res = new[] { xs, ys }.OnErrorResumeNext(); - Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 })); + Assert.True(Enumerable.SequenceEqual(res, [1, 2, 3, 4])); } [Fact] @@ -79,7 +79,7 @@ public void OnErrorResumeNext6() var ys = new[] { 3, 4 }; var res = new[] { xs, ys }.OnErrorResumeNext(); - Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 2, 3, 4 })); + Assert.True(Enumerable.SequenceEqual(res, [1, 2, 3, 4])); } private sealed class MyException : Exception diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Publish.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Publish.cs index 8ebcf19ab2..a627283b14 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Publish.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Publish.cs @@ -226,7 +226,7 @@ public void Publish10() public void PublishLambda_Arguments() { AssertThrows(() => EnumerableEx.Publish(null, xs => xs)); - AssertThrows(() => EnumerableEx.Publish(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.Publish([1], null)); } [Fact] @@ -248,12 +248,12 @@ private static IEnumerable Tick(Action t) } } - private static readonly Random s_rand = new Random(); + private static readonly Random RandSource = new(); private static IEnumerable Rand() { while (true) - yield return s_rand.Next(); + yield return RandSource.Next(); } } } diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Repeat.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Repeat.cs index c7d215d651..a07814ad0e 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Repeat.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Repeat.cs @@ -23,7 +23,7 @@ public void RepeatSequence_Arguments() { AssertThrows(() => EnumerableEx.Repeat(null)); AssertThrows(() => EnumerableEx.Repeat(null, 5)); - AssertThrows(() => EnumerableEx.Repeat(new[] { 1 }, -1)); + AssertThrows(() => EnumerableEx.Repeat([1], -1)); } [Fact] diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Retry.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Retry.cs index c315e100fa..cf0869b9c1 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Retry.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Retry.cs @@ -15,7 +15,7 @@ public void Retry_Arguments() { AssertThrows(() => EnumerableEx.Retry(null)); AssertThrows(() => EnumerableEx.Retry(null, 5)); - AssertThrows(() => EnumerableEx.Retry(new[] { 1 }, -1)); + AssertThrows(() => EnumerableEx.Retry([1], -1)); } [Fact] diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Scan.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Scan.cs index 282f0c279f..e0198b504b 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Scan.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Scan.cs @@ -14,23 +14,23 @@ public class Scan : Tests public void Scan_Arguments() { AssertThrows(() => EnumerableEx.Scan(null, (x, y) => x + y)); - AssertThrows(() => EnumerableEx.Scan(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.Scan([1], null)); AssertThrows(() => EnumerableEx.Scan(null, 0, (x, y) => x + y)); - AssertThrows(() => EnumerableEx.Scan(new[] { 1 }, 0, null)); + AssertThrows(() => EnumerableEx.Scan([1], 0, null)); } [Fact] public void Scan1() { var res = Enumerable.Range(0, 5).Scan((n, x) => n + x).ToList(); - Assert.True(Enumerable.SequenceEqual(res, new[] { 1, 3, 6, 10 })); + Assert.True(Enumerable.SequenceEqual(res, [1, 3, 6, 10])); } [Fact] public void Scan2() { var res = Enumerable.Range(0, 5).Scan(10, (n, x) => n - x).ToList(); - Assert.True(Enumerable.SequenceEqual(res, new[] { 10, 9, 7, 4, 0 })); + Assert.True(Enumerable.SequenceEqual(res, [10, 9, 7, 4, 0])); } } } diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/SelectMany.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/SelectMany.cs index 36bc8a1d5d..bb56c6fff8 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/SelectMany.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/SelectMany.cs @@ -13,15 +13,15 @@ public class SelectMany : Tests [Fact] public void SelectMany_Arguments() { - AssertThrows(() => EnumerableEx.SelectMany(null, new[] { 1 })); - AssertThrows(() => EnumerableEx.SelectMany(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.SelectMany(null, [1])); + AssertThrows(() => EnumerableEx.SelectMany([1], null)); } [Fact] public void SelectMany1() { var res = new[] { 1, 2 }.SelectMany(new[] { 'a', 'b', 'c' }).ToList(); - Assert.True(Enumerable.SequenceEqual(res, new[] { 'a', 'b', 'c', 'a', 'b', 'c' })); + Assert.True(Enumerable.SequenceEqual(res, ['a', 'b', 'c', 'a', 'b', 'c'])); } } } diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Share.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Share.cs index 126ee9e770..a91f96d0bc 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Share.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Share.cs @@ -64,7 +64,7 @@ public void Share3() NoNext(e1); } - //[Fact] + [Fact] public void Share4() { var rng = Enumerable.Range(0, 5).Share(); @@ -108,7 +108,7 @@ public void Share6() public void ShareLambda_Arguments() { AssertThrows(() => EnumerableEx.Share(null, xs => xs)); - AssertThrows(() => EnumerableEx.Share(new[] { 1 }, null)); + AssertThrows(() => EnumerableEx.Share([1], null)); } [Fact] @@ -116,7 +116,7 @@ public void ShareLambda() { var n = 0; var res = Enumerable.Range(0, 10).Do(_ => n++).Share(xs => xs.Zip(xs, (l, r) => l + r).Take(4)).ToList(); - Assert.True(res.SequenceEqual(new[] { 0 + 1, 2 + 3, 4 + 5, 6 + 7 })); + Assert.True(res.SequenceEqual([0 + 1, 2 + 3, 4 + 5, 6 + 7])); Assert.Equal(8, n); } } diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/SkipLast.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/SkipLast.cs index 53b56a1943..b241193e14 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/SkipLast.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/SkipLast.cs @@ -15,7 +15,7 @@ public class SkipLast : Tests public void SkipLast_Arguments() { AssertThrows(() => EnumerableEx.SkipLast(null, 5)); - AssertThrows(() => EnumerableEx.SkipLast(new[] { 1 }, -1)); + AssertThrows(() => EnumerableEx.SkipLast([1], -1)); } [Fact] diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/TakeLast.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/TakeLast.cs index d09d8b1394..1c98f72188 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/TakeLast.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/TakeLast.cs @@ -15,7 +15,7 @@ public class TakeLast : Tests public void TakeLast_Arguments() { AssertThrows(() => EnumerableEx.TakeLast(null, 5)); - AssertThrows(() => EnumerableEx.TakeLast(new[] { 1 }, -1)); + AssertThrows(() => EnumerableEx.TakeLast([1], -1)); } [Fact] @@ -23,7 +23,7 @@ public void TakeLast_TakeZero() { var e = Enumerable.Range(1, 5); var r = e.TakeLast(0).ToList(); - Assert.True(Enumerable.SequenceEqual(r, Enumerable.Empty())); + Assert.True(Enumerable.SequenceEqual(r, [])); } [Fact] diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Using.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Using.cs index e435be6545..f2559ff410 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Using.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/Using.cs @@ -13,7 +13,7 @@ public class Using : Tests [Fact] public void Using_Arguments() { - AssertThrows(() => EnumerableEx.Using(null, d => new[] { 1 })); + AssertThrows(() => EnumerableEx.Using(null, d => [1])); AssertThrows(() => EnumerableEx.Using(() => new MyDisposable(), null)); } diff --git a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/While.cs b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/While.cs index 663afa6a1d..813771fb8b 100644 --- a/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/While.cs +++ b/Ix.NET/Source/System.Interactive.Tests/System/Linq/Operators/While.cs @@ -13,7 +13,7 @@ public class While : Tests [Fact] public void While_Arguments() { - AssertThrows(() => EnumerableEx.While(null, new[] { 1 })); + AssertThrows(() => EnumerableEx.While(null, [1])); AssertThrows(() => EnumerableEx.While(() => true, null)); } @@ -22,7 +22,7 @@ public void While1() { var x = 5; var res = EnumerableEx.While(() => x > 0, EnumerableEx.Defer(() => new[] { x }).Do(_ => x--)).ToList(); - Assert.True(Enumerable.SequenceEqual(res, new[] { 5, 4, 3, 2, 1 })); + Assert.True(Enumerable.SequenceEqual(res, [5, 4, 3, 2, 1])); } [Fact] @@ -30,7 +30,7 @@ public void While2() { var x = 0; var res = EnumerableEx.While(() => x > 0, EnumerableEx.Defer(() => new[] { x }).Do(_ => x--)).ToList(); - Assert.True(Enumerable.SequenceEqual(res, new int[0])); + Assert.True(Enumerable.SequenceEqual(res, [])); } } } diff --git a/Ix.NET/Source/System.Interactive.Tests/Tests.cs b/Ix.NET/Source/System.Interactive.Tests/Tests.cs index d5f44e2d0a..9802ed6de8 100644 --- a/Ix.NET/Source/System.Interactive.Tests/Tests.cs +++ b/Ix.NET/Source/System.Interactive.Tests/Tests.cs @@ -10,7 +10,6 @@ namespace Tests { public partial class Tests { -#pragma warning disable xUnit1013 // Public method should be marked as test public void AssertThrows(Action a) where E : Exception { @@ -41,6 +40,5 @@ public void HasNext(IEnumerator e, T value) Assert.True(e.MoveNext()); Assert.Equal(value, e.Current); } -#pragma warning restore xUnit1013 // Public method should be marked as test } } diff --git a/Ix.NET/Source/System.Interactive/System.Interactive.csproj b/Ix.NET/Source/System.Interactive/System.Interactive.csproj index 44dbc3967a..974b42d95a 100644 --- a/Ix.NET/Source/System.Interactive/System.Interactive.csproj +++ b/Ix.NET/Source/System.Interactive/System.Interactive.csproj @@ -1,4 +1,4 @@ - + Interactive Extensions Main Library used to express queries over enumerable sequences. @@ -10,7 +10,32 @@ - + + + + + + + + + + + $(NoWarn);NU5128;NU5131 + + diff --git a/Ix.NET/Source/System.Interactive/System/Linq/MaxRefCountList.cs b/Ix.NET/Source/System.Interactive/System/Linq/MaxRefCountList.cs index 26423cb55e..7d6391c5c1 100644 --- a/Ix.NET/Source/System.Interactive/System/Linq/MaxRefCountList.cs +++ b/Ix.NET/Source/System.Interactive/System/Linq/MaxRefCountList.cs @@ -9,7 +9,7 @@ namespace System.Linq { internal sealed class MaxRefCountList : IRefCountList { - private readonly IList _list = new List(); + private readonly IList _list = []; public void Clear() => _list.Clear(); diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Case.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Case.cs index 4eb277f71e..aef57924a4 100644 --- a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Case.cs +++ b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Case.cs @@ -23,7 +23,7 @@ public static IEnumerable Case(Func selector, if (sources == null) throw new ArgumentNullException(nameof(sources)); - return Case(selector, sources, Enumerable.Empty()); + return Case(selector, sources, []); } /// diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Create.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Create.cs index cd156f0fbe..ddb6191516 100644 --- a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Create.cs +++ b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Create.cs @@ -43,13 +43,9 @@ public static IEnumerable Create(Action> create) } } - private sealed class AnonymousEnumerable : IEnumerable + private sealed class AnonymousEnumerable(Func> getEnumerator) : IEnumerable { - private readonly Func> _getEnumerator; - - public AnonymousEnumerable(Func> getEnumerator) => _getEnumerator = getEnumerator; - - public IEnumerator GetEnumerator() => _getEnumerator(); + public IEnumerator GetEnumerator() => getEnumerator(); IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); } diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/If.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/If.cs index 6b7c028d5d..633cead274 100644 --- a/Ix.NET/Source/System.Interactive/System/Linq/Operators/If.cs +++ b/Ix.NET/Source/System.Interactive/System/Linq/Operators/If.cs @@ -43,7 +43,7 @@ public static IEnumerable If(Func condition, IEnumerable if (thenSource == null) throw new ArgumentNullException(nameof(thenSource)); - return Defer(() => condition() ? thenSource : Enumerable.Empty()); + return Defer(() => condition() ? thenSource : []); } } } diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/MaxByWithTies.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/MaxByWithTies.cs index c71d1f6cde..edecbeaa74 100644 --- a/Ix.NET/Source/System.Interactive/System/Linq/Operators/MaxByWithTies.cs +++ b/Ix.NET/Source/System.Interactive/System/Linq/Operators/MaxByWithTies.cs @@ -72,7 +72,7 @@ private static IList ExtremaBy(IEnumerable sour } else if (cmp > 0) { - result = new List { cur }; + result = [cur]; resKey = key; } } diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Memoize.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Memoize.cs index ceaea06378..292582f245 100644 --- a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Memoize.cs +++ b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Memoize.cs @@ -113,7 +113,7 @@ public static IEnumerable Memoize(this IEnumerable : IBuffer { - private readonly object _gate = new object(); + private readonly object _gate = new(); private readonly IRefCountList _buffer; private readonly IEnumerator _source; @@ -231,8 +231,7 @@ private IEnumerator GetEnumerator_() } finally { - if (_buffer != null) - _buffer.Done(i + 1); + _buffer?.Done(i + 1); } } } diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Publish.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Publish.cs index 6ed44021ab..fe490bbee7 100644 --- a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Publish.cs +++ b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Publish.cs @@ -61,7 +61,7 @@ public static IEnumerable Publish(this IEnumerable : IBuffer { - private readonly object _gate = new object(); + private readonly object _gate = new(); private readonly RefCountList _buffer; private readonly IEnumerator _source; diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Share.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Share.cs index 99d9b0604e..55a5529e1f 100644 --- a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Share.cs +++ b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Share.cs @@ -56,16 +56,11 @@ public static IEnumerable Share(this IEnumerable selector(source.Share()).GetEnumerator()); } - private class SharedBuffer : IBuffer + private class SharedBuffer(IEnumerator source) : IBuffer { - private readonly IEnumerator _source; + private readonly IEnumerator _source = source; private bool _disposed; - public SharedBuffer(IEnumerator source) - { - _source = source; - } - public IEnumerator GetEnumerator() { if (_disposed) diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/SkipLast.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/SkipLast.cs index 58efac23cb..662d6c739e 100644 --- a/Ix.NET/Source/System.Interactive/System/Linq/Operators/SkipLast.cs +++ b/Ix.NET/Source/System.Interactive/System/Linq/Operators/SkipLast.cs @@ -28,7 +28,6 @@ public static IEnumerable SkipLast(this IEnumerable s return SkipLastCore(source, count); } -#endif private static IEnumerable SkipLastCore(this IEnumerable source, int count) { @@ -44,5 +43,6 @@ private static IEnumerable SkipLastCore(this IEnumerable TakeLast(this IEnumerable s return TakeLastCore(source, count); } -#endif private static IEnumerable TakeLastCore(IEnumerable source, int count) { @@ -51,5 +50,6 @@ private static IEnumerable TakeLastCore(IEnumerable s yield return q.Dequeue(); } } +#endif } } diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Throw.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Throw.cs index 96b897018e..493886d487 100644 --- a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Throw.cs +++ b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Throw.cs @@ -25,9 +25,9 @@ public static IEnumerable Throw(Exception exception) private static IEnumerable ThrowCore(Exception exception) { throw exception; -#pragma warning disable 0162 +#pragma warning disable CS0162 // Unreachable code detected yield break; -#pragma warning restore 0162 +#pragma warning restore CS0162 // Unreachable code detected } } } diff --git a/Ix.NET/Source/System.Interactive/System/Linq/RefCountList.cs b/Ix.NET/Source/System.Interactive/System/Linq/RefCountList.cs index 2bf849d9fb..4b81e1f852 100644 --- a/Ix.NET/Source/System.Interactive/System/Linq/RefCountList.cs +++ b/Ix.NET/Source/System.Interactive/System/Linq/RefCountList.cs @@ -7,17 +7,11 @@ namespace System.Linq { - internal sealed class RefCountList : IRefCountList + internal sealed class RefCountList(int readerCount) : IRefCountList { - private readonly IDictionary _list; + private readonly IDictionary _list = new Dictionary(); - public RefCountList(int readerCount) - { - ReaderCount = readerCount; - _list = new Dictionary(); - } - - public int ReaderCount { get; set; } + public int ReaderCount { get; set; } = readerCount; public void Clear() => _list.Clear(); diff --git a/Ix.NET/Source/System.Linq.Async.Queryable.Tests/System.Linq.Async.Queryable.Tests.csproj b/Ix.NET/Source/System.Linq.Async.Queryable.Tests/System.Linq.Async.Queryable.Tests.csproj index 6abdffd2c9..c425155943 100644 --- a/Ix.NET/Source/System.Linq.Async.Queryable.Tests/System.Linq.Async.Queryable.Tests.csproj +++ b/Ix.NET/Source/System.Linq.Async.Queryable.Tests/System.Linq.Async.Queryable.Tests.csproj @@ -1,7 +1,8 @@  - net48;net6.0;netcoreapp3.1 + + net48;net8.0;net6.0;netcoreapp3.1 $(NoWarn);CS0618 diff --git a/Ix.NET/Source/System.Linq.Async.Queryable/System.Linq.Async.Queryable.csproj b/Ix.NET/Source/System.Linq.Async.Queryable/System.Linq.Async.Queryable.csproj index 49a175d557..f653bc91af 100644 --- a/Ix.NET/Source/System.Linq.Async.Queryable/System.Linq.Async.Queryable.csproj +++ b/Ix.NET/Source/System.Linq.Async.Queryable/System.Linq.Async.Queryable.csproj @@ -25,4 +25,9 @@ TextTemplatingFileGenerator + + + + + diff --git a/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncEnumerableQuery.cs b/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncEnumerableQuery.cs index ee89a1bbe2..54723e3d4e 100644 --- a/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncEnumerableQuery.cs +++ b/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncEnumerableQuery.cs @@ -135,7 +135,7 @@ public IAsyncEnumerator GetAsyncEnumerator(CancellationToken token) /// String representation of the enumerable sequence. public override string? ToString() { - if (!(_expression is ConstantExpression ce) || ce.Value != this) + if (_expression is not ConstantExpression ce || ce.Value != this) { return _expression.ToString(); } diff --git a/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncEnumerableRewriter.cs b/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncEnumerableRewriter.cs index fcf7135680..11739e5503 100644 --- a/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncEnumerableRewriter.cs +++ b/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncEnumerableRewriter.cs @@ -23,7 +23,7 @@ protected override Expression VisitConstant(ConstantExpression node) // Not an expression representation obtained from the async enumerable query provider, // so just a plain constant that can be returned as-is. // - if (!(node.Value is AsyncEnumerableQuery enumerableQuery)) + if (node.Value is not AsyncEnumerableQuery enumerableQuery) { return node; } @@ -46,7 +46,7 @@ protected override Expression VisitConstant(ConstantExpression node) protected override Expression VisitMethodCall(MethodCallExpression node) { - var obj = Visit(node.Object); + var obj = Visit(node.Object)!; var args = Visit(node.Arguments); // @@ -396,10 +396,7 @@ private static MethodInfo FindEnumerableMethod(string name, ReadOnlyCollection m.Name); - } + _methods ??= typeof(AsyncEnumerable).GetMethods(BindingFlags.Static | BindingFlags.Public).ToLookup(m => m.Name); // // Find a match based on the method name and the argument types. diff --git a/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.Generated.cs b/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.Generated.cs index 9958f5ee59..a5cde71381 100644 --- a/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.Generated.cs +++ b/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.Generated.cs @@ -16,7 +16,7 @@ public static partial class AsyncQueryable { private static MethodInfo? s_AggregateAsync__TSource__3__0; - private static MethodInfo? AggregateAsync__TSource__3__0(Type TSource) => + private static MethodInfo AggregateAsync__TSource__3__0(Type TSource) => (s_AggregateAsync__TSource__3__0 ?? (s_AggregateAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(AggregateAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -32,7 +32,7 @@ public static ValueTask AggregateAsync(this IAsyncQueryable + private static MethodInfo AggregateAsync__TSource_TAccumulate__4__0(Type TSource, Type TAccumulate) => (s_AggregateAsync__TSource_TAccumulate__4__0 ?? (s_AggregateAsync__TSource_TAccumulate__4__0 = new Func, object, Expression>, CancellationToken, ValueTask>(AggregateAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TAccumulate); @@ -48,7 +48,7 @@ public static ValueTask AggregateAsync(this I private static MethodInfo? s_AggregateAsync__TSource_TAccumulate_TResult__5__0; - private static MethodInfo? AggregateAsync__TSource_TAccumulate_TResult__5__0(Type TSource, Type TAccumulate, Type TResult) => + private static MethodInfo AggregateAsync__TSource_TAccumulate_TResult__5__0(Type TSource, Type TAccumulate, Type TResult) => (s_AggregateAsync__TSource_TAccumulate_TResult__5__0 ?? (s_AggregateAsync__TSource_TAccumulate_TResult__5__0 = new Func, object, Expression>, Expression>, CancellationToken, ValueTask>(AggregateAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TAccumulate, TResult); @@ -66,7 +66,7 @@ public static ValueTask AggregateAsync(t private static MethodInfo? s_AggregateAwaitAsync__TSource__3__0; - private static MethodInfo? AggregateAwaitAsync__TSource__3__0(Type TSource) => + private static MethodInfo AggregateAwaitAsync__TSource__3__0(Type TSource) => (s_AggregateAwaitAsync__TSource__3__0 ?? (s_AggregateAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(AggregateAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -82,7 +82,7 @@ public static ValueTask AggregateAwaitAsync(this IAsyncQueryab private static MethodInfo? s_AggregateAwaitAsync__TSource_TAccumulate__4__0; - private static MethodInfo? AggregateAwaitAsync__TSource_TAccumulate__4__0(Type TSource, Type TAccumulate) => + private static MethodInfo AggregateAwaitAsync__TSource_TAccumulate__4__0(Type TSource, Type TAccumulate) => (s_AggregateAwaitAsync__TSource_TAccumulate__4__0 ?? (s_AggregateAwaitAsync__TSource_TAccumulate__4__0 = new Func, object, Expression>>, CancellationToken, ValueTask>(AggregateAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TAccumulate); @@ -98,7 +98,7 @@ public static ValueTask AggregateAwaitAsync(t private static MethodInfo? s_AggregateAwaitAsync__TSource_TAccumulate_TResult__5__0; - private static MethodInfo? AggregateAwaitAsync__TSource_TAccumulate_TResult__5__0(Type TSource, Type TAccumulate, Type TResult) => + private static MethodInfo AggregateAwaitAsync__TSource_TAccumulate_TResult__5__0(Type TSource, Type TAccumulate, Type TResult) => (s_AggregateAwaitAsync__TSource_TAccumulate_TResult__5__0 ?? (s_AggregateAwaitAsync__TSource_TAccumulate_TResult__5__0 = new Func, object, Expression>>, Expression>>, CancellationToken, ValueTask>(AggregateAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TAccumulate, TResult); @@ -116,7 +116,7 @@ public static ValueTask AggregateAwaitAsync + private static MethodInfo AggregateAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_AggregateAwaitWithCancellationAsync__TSource__3__0 ?? (s_AggregateAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(AggregateAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -132,7 +132,7 @@ public static ValueTask AggregateAwaitWithCancellationAsync(th private static MethodInfo? s_AggregateAwaitWithCancellationAsync__TSource_TAccumulate__4__0; - private static MethodInfo? AggregateAwaitWithCancellationAsync__TSource_TAccumulate__4__0(Type TSource, Type TAccumulate) => + private static MethodInfo AggregateAwaitWithCancellationAsync__TSource_TAccumulate__4__0(Type TSource, Type TAccumulate) => (s_AggregateAwaitWithCancellationAsync__TSource_TAccumulate__4__0 ?? (s_AggregateAwaitWithCancellationAsync__TSource_TAccumulate__4__0 = new Func, object, Expression>>, CancellationToken, ValueTask>(AggregateAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TAccumulate); @@ -148,7 +148,7 @@ public static ValueTask AggregateAwaitWithCancellationAsync + private static MethodInfo AggregateAwaitWithCancellationAsync__TSource_TAccumulate_TResult__5__0(Type TSource, Type TAccumulate, Type TResult) => (s_AggregateAwaitWithCancellationAsync__TSource_TAccumulate_TResult__5__0 ?? (s_AggregateAwaitWithCancellationAsync__TSource_TAccumulate_TResult__5__0 = new Func, object, Expression>>, Expression>>, CancellationToken, ValueTask>(AggregateAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TAccumulate, TResult); @@ -166,7 +166,7 @@ public static ValueTask AggregateAwaitWithCancellationAsync + private static MethodInfo AllAsync__TSource__3__0(Type TSource) => (s_AllAsync__TSource__3__0 ?? (s_AllAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(AllAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -182,7 +182,7 @@ public static ValueTask AllAsync(this IAsyncQueryable so private static MethodInfo? s_AllAwaitAsync__TSource__3__0; - private static MethodInfo? AllAwaitAsync__TSource__3__0(Type TSource) => + private static MethodInfo AllAwaitAsync__TSource__3__0(Type TSource) => (s_AllAwaitAsync__TSource__3__0 ?? (s_AllAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(AllAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -198,7 +198,7 @@ public static ValueTask AllAwaitAsync(this IAsyncQueryable + private static MethodInfo AllAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_AllAwaitWithCancellationAsync__TSource__3__0 ?? (s_AllAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(AllAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -214,7 +214,7 @@ public static ValueTask AllAwaitWithCancellationAsync(this IAsync private static MethodInfo? s_AnyAsync__TSource__2__0; - private static MethodInfo? AnyAsync__TSource__2__0(Type TSource) => + private static MethodInfo AnyAsync__TSource__2__0(Type TSource) => (s_AnyAsync__TSource__2__0 ?? (s_AnyAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(AnyAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -228,7 +228,7 @@ public static ValueTask AnyAsync(this IAsyncQueryable so private static MethodInfo? s_AnyAsync__TSource__3__0; - private static MethodInfo? AnyAsync__TSource__3__0(Type TSource) => + private static MethodInfo AnyAsync__TSource__3__0(Type TSource) => (s_AnyAsync__TSource__3__0 ?? (s_AnyAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(AnyAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -244,7 +244,7 @@ public static ValueTask AnyAsync(this IAsyncQueryable so private static MethodInfo? s_AnyAwaitAsync__TSource__3__0; - private static MethodInfo? AnyAwaitAsync__TSource__3__0(Type TSource) => + private static MethodInfo AnyAwaitAsync__TSource__3__0(Type TSource) => (s_AnyAwaitAsync__TSource__3__0 ?? (s_AnyAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(AnyAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -260,7 +260,7 @@ public static ValueTask AnyAwaitAsync(this IAsyncQueryable + private static MethodInfo AnyAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_AnyAwaitWithCancellationAsync__TSource__3__0 ?? (s_AnyAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(AnyAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -276,7 +276,7 @@ public static ValueTask AnyAwaitWithCancellationAsync(this IAsync private static MethodInfo? s_Append__TSource__2__0; - private static MethodInfo? Append__TSource__2__0(Type TSource) => + private static MethodInfo Append__TSource__2__0(Type TSource) => (s_Append__TSource__2__0 ?? (s_Append__TSource__2__0 = new Func, object, IAsyncQueryable>(Append).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -290,7 +290,7 @@ public static IAsyncQueryable Append(this IAsyncQueryable + private static MethodInfo AverageAsync__2__0 => (s_AverageAsync__2__0 ?? (s_AverageAsync__2__0 = new Func, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo())); @@ -304,7 +304,7 @@ public static IAsyncQueryable Append(this IAsyncQueryable + private static MethodInfo AverageAsync__2__1 => (s_AverageAsync__2__1 ?? (s_AverageAsync__2__1 = new Func, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo())); @@ -318,7 +318,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable sour private static MethodInfo? s_AverageAsync__2__2; - private static MethodInfo? AverageAsync__2__2 => + private static MethodInfo AverageAsync__2__2 => (s_AverageAsync__2__2 ?? (s_AverageAsync__2__2 = new Func, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo())); @@ -332,7 +332,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable sour private static MethodInfo? s_AverageAsync__2__3; - private static MethodInfo? AverageAsync__2__3 => + private static MethodInfo AverageAsync__2__3 => (s_AverageAsync__2__3 ?? (s_AverageAsync__2__3 = new Func, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo())); @@ -346,7 +346,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable source private static MethodInfo? s_AverageAsync__2__4; - private static MethodInfo? AverageAsync__2__4 => + private static MethodInfo AverageAsync__2__4 => (s_AverageAsync__2__4 ?? (s_AverageAsync__2__4 = new Func, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo())); @@ -360,7 +360,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable source private static MethodInfo? s_AverageAsync__2__5; - private static MethodInfo? AverageAsync__2__5 => + private static MethodInfo AverageAsync__2__5 => (s_AverageAsync__2__5 ?? (s_AverageAsync__2__5 = new Func, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo())); @@ -374,7 +374,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable source, private static MethodInfo? s_AverageAsync__2__6; - private static MethodInfo? AverageAsync__2__6 => + private static MethodInfo AverageAsync__2__6 => (s_AverageAsync__2__6 ?? (s_AverageAsync__2__6 = new Func, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo())); @@ -388,7 +388,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable source, private static MethodInfo? s_AverageAsync__2__7; - private static MethodInfo? AverageAsync__2__7 => + private static MethodInfo AverageAsync__2__7 => (s_AverageAsync__2__7 ?? (s_AverageAsync__2__7 = new Func, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo())); @@ -402,7 +402,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable source, C private static MethodInfo? s_AverageAsync__2__8; - private static MethodInfo? AverageAsync__2__8 => + private static MethodInfo AverageAsync__2__8 => (s_AverageAsync__2__8 ?? (s_AverageAsync__2__8 = new Func, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo())); @@ -416,7 +416,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable source, C private static MethodInfo? s_AverageAsync__2__9; - private static MethodInfo? AverageAsync__2__9 => + private static MethodInfo AverageAsync__2__9 => (s_AverageAsync__2__9 ?? (s_AverageAsync__2__9 = new Func, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo())); @@ -430,7 +430,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable source, private static MethodInfo? s_AverageAsync__TSource__3__0; - private static MethodInfo? AverageAsync__TSource__3__0(Type TSource) => + private static MethodInfo AverageAsync__TSource__3__0(Type TSource) => (s_AverageAsync__TSource__3__0 ?? (s_AverageAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -446,7 +446,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable source, private static MethodInfo? s_AverageAsync__TSource__3__1; - private static MethodInfo? AverageAsync__TSource__3__1(Type TSource) => + private static MethodInfo AverageAsync__TSource__3__1(Type TSource) => (s_AverageAsync__TSource__3__1 ?? (s_AverageAsync__TSource__3__1 = new Func, Expression>, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -462,7 +462,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable + private static MethodInfo AverageAsync__TSource__3__2(Type TSource) => (s_AverageAsync__TSource__3__2 ?? (s_AverageAsync__TSource__3__2 = new Func, Expression>, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -478,7 +478,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable + private static MethodInfo AverageAsync__TSource__3__3(Type TSource) => (s_AverageAsync__TSource__3__3 ?? (s_AverageAsync__TSource__3__3 = new Func, Expression>, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -494,7 +494,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable + private static MethodInfo AverageAsync__TSource__3__4(Type TSource) => (s_AverageAsync__TSource__3__4 ?? (s_AverageAsync__TSource__3__4 = new Func, Expression>, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -510,7 +510,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable + private static MethodInfo AverageAsync__TSource__3__5(Type TSource) => (s_AverageAsync__TSource__3__5 ?? (s_AverageAsync__TSource__3__5 = new Func, Expression>, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -526,7 +526,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable + private static MethodInfo AverageAsync__TSource__3__6(Type TSource) => (s_AverageAsync__TSource__3__6 ?? (s_AverageAsync__TSource__3__6 = new Func, Expression>, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -542,7 +542,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable + private static MethodInfo AverageAsync__TSource__3__7(Type TSource) => (s_AverageAsync__TSource__3__7 ?? (s_AverageAsync__TSource__3__7 = new Func, Expression>, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -558,7 +558,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable + private static MethodInfo AverageAsync__TSource__3__8(Type TSource) => (s_AverageAsync__TSource__3__8 ?? (s_AverageAsync__TSource__3__8 = new Func, Expression>, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -574,7 +574,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable + private static MethodInfo AverageAsync__TSource__3__9(Type TSource) => (s_AverageAsync__TSource__3__9 ?? (s_AverageAsync__TSource__3__9 = new Func, Expression>, CancellationToken, ValueTask>(AverageAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -590,7 +590,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable + private static MethodInfo AverageAwaitAsync__TSource__3__0(Type TSource) => (s_AverageAwaitAsync__TSource__3__0 ?? (s_AverageAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -606,7 +606,7 @@ public static ValueTask AverageAsync(this IAsyncQueryable + private static MethodInfo AverageAwaitAsync__TSource__3__1(Type TSource) => (s_AverageAwaitAsync__TSource__3__1 ?? (s_AverageAwaitAsync__TSource__3__1 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -622,7 +622,7 @@ public static ValueTask AverageAwaitAsync(this IAsyncQueryable private static MethodInfo? s_AverageAwaitAsync__TSource__3__2; - private static MethodInfo? AverageAwaitAsync__TSource__3__2(Type TSource) => + private static MethodInfo AverageAwaitAsync__TSource__3__2(Type TSource) => (s_AverageAwaitAsync__TSource__3__2 ?? (s_AverageAwaitAsync__TSource__3__2 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -638,7 +638,7 @@ public static ValueTask AverageAwaitAsync(this IAsyncQueryable private static MethodInfo? s_AverageAwaitAsync__TSource__3__3; - private static MethodInfo? AverageAwaitAsync__TSource__3__3(Type TSource) => + private static MethodInfo AverageAwaitAsync__TSource__3__3(Type TSource) => (s_AverageAwaitAsync__TSource__3__3 ?? (s_AverageAwaitAsync__TSource__3__3 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -654,7 +654,7 @@ public static ValueTask AverageAwaitAsync(this IAsyncQueryable< private static MethodInfo? s_AverageAwaitAsync__TSource__3__4; - private static MethodInfo? AverageAwaitAsync__TSource__3__4(Type TSource) => + private static MethodInfo AverageAwaitAsync__TSource__3__4(Type TSource) => (s_AverageAwaitAsync__TSource__3__4 ?? (s_AverageAwaitAsync__TSource__3__4 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -670,7 +670,7 @@ public static ValueTask AverageAwaitAsync(this IAsyncQueryable< private static MethodInfo? s_AverageAwaitAsync__TSource__3__5; - private static MethodInfo? AverageAwaitAsync__TSource__3__5(Type TSource) => + private static MethodInfo AverageAwaitAsync__TSource__3__5(Type TSource) => (s_AverageAwaitAsync__TSource__3__5 ?? (s_AverageAwaitAsync__TSource__3__5 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -686,7 +686,7 @@ public static ValueTask AverageAwaitAsync(this IAsyncQueryable + private static MethodInfo AverageAwaitAsync__TSource__3__6(Type TSource) => (s_AverageAwaitAsync__TSource__3__6 ?? (s_AverageAwaitAsync__TSource__3__6 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -702,7 +702,7 @@ public static ValueTask AverageAwaitAsync(this IAsyncQueryable + private static MethodInfo AverageAwaitAsync__TSource__3__7(Type TSource) => (s_AverageAwaitAsync__TSource__3__7 ?? (s_AverageAwaitAsync__TSource__3__7 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -718,7 +718,7 @@ public static ValueTask AverageAwaitAsync(this IAsyncQueryable< private static MethodInfo? s_AverageAwaitAsync__TSource__3__8; - private static MethodInfo? AverageAwaitAsync__TSource__3__8(Type TSource) => + private static MethodInfo AverageAwaitAsync__TSource__3__8(Type TSource) => (s_AverageAwaitAsync__TSource__3__8 ?? (s_AverageAwaitAsync__TSource__3__8 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -734,7 +734,7 @@ public static ValueTask AverageAwaitAsync(this IAsyncQueryable< private static MethodInfo? s_AverageAwaitAsync__TSource__3__9; - private static MethodInfo? AverageAwaitAsync__TSource__3__9(Type TSource) => + private static MethodInfo AverageAwaitAsync__TSource__3__9(Type TSource) => (s_AverageAwaitAsync__TSource__3__9 ?? (s_AverageAwaitAsync__TSource__3__9 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -750,7 +750,7 @@ public static ValueTask AverageAwaitAsync(this IAsyncQueryable< private static MethodInfo? s_AverageAwaitWithCancellationAsync__TSource__3__0; - private static MethodInfo? AverageAwaitWithCancellationAsync__TSource__3__0(Type TSource) => + private static MethodInfo AverageAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_AverageAwaitWithCancellationAsync__TSource__3__0 ?? (s_AverageAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -766,7 +766,7 @@ public static ValueTask AverageAwaitAsync(this IAsyncQueryable< private static MethodInfo? s_AverageAwaitWithCancellationAsync__TSource__3__1; - private static MethodInfo? AverageAwaitWithCancellationAsync__TSource__3__1(Type TSource) => + private static MethodInfo AverageAwaitWithCancellationAsync__TSource__3__1(Type TSource) => (s_AverageAwaitWithCancellationAsync__TSource__3__1 ?? (s_AverageAwaitWithCancellationAsync__TSource__3__1 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -782,7 +782,7 @@ public static ValueTask AverageAwaitWithCancellationAsync(this private static MethodInfo? s_AverageAwaitWithCancellationAsync__TSource__3__2; - private static MethodInfo? AverageAwaitWithCancellationAsync__TSource__3__2(Type TSource) => + private static MethodInfo AverageAwaitWithCancellationAsync__TSource__3__2(Type TSource) => (s_AverageAwaitWithCancellationAsync__TSource__3__2 ?? (s_AverageAwaitWithCancellationAsync__TSource__3__2 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -798,7 +798,7 @@ public static ValueTask AverageAwaitWithCancellationAsync(this private static MethodInfo? s_AverageAwaitWithCancellationAsync__TSource__3__3; - private static MethodInfo? AverageAwaitWithCancellationAsync__TSource__3__3(Type TSource) => + private static MethodInfo AverageAwaitWithCancellationAsync__TSource__3__3(Type TSource) => (s_AverageAwaitWithCancellationAsync__TSource__3__3 ?? (s_AverageAwaitWithCancellationAsync__TSource__3__3 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -814,7 +814,7 @@ public static ValueTask AverageAwaitWithCancellationAsync(this private static MethodInfo? s_AverageAwaitWithCancellationAsync__TSource__3__4; - private static MethodInfo? AverageAwaitWithCancellationAsync__TSource__3__4(Type TSource) => + private static MethodInfo AverageAwaitWithCancellationAsync__TSource__3__4(Type TSource) => (s_AverageAwaitWithCancellationAsync__TSource__3__4 ?? (s_AverageAwaitWithCancellationAsync__TSource__3__4 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -830,7 +830,7 @@ public static ValueTask AverageAwaitWithCancellationAsync(this private static MethodInfo? s_AverageAwaitWithCancellationAsync__TSource__3__5; - private static MethodInfo? AverageAwaitWithCancellationAsync__TSource__3__5(Type TSource) => + private static MethodInfo AverageAwaitWithCancellationAsync__TSource__3__5(Type TSource) => (s_AverageAwaitWithCancellationAsync__TSource__3__5 ?? (s_AverageAwaitWithCancellationAsync__TSource__3__5 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -846,7 +846,7 @@ public static ValueTask AverageAwaitWithCancellationAsync(this I private static MethodInfo? s_AverageAwaitWithCancellationAsync__TSource__3__6; - private static MethodInfo? AverageAwaitWithCancellationAsync__TSource__3__6(Type TSource) => + private static MethodInfo AverageAwaitWithCancellationAsync__TSource__3__6(Type TSource) => (s_AverageAwaitWithCancellationAsync__TSource__3__6 ?? (s_AverageAwaitWithCancellationAsync__TSource__3__6 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -862,7 +862,7 @@ public static ValueTask AverageAwaitWithCancellationAsync(this I private static MethodInfo? s_AverageAwaitWithCancellationAsync__TSource__3__7; - private static MethodInfo? AverageAwaitWithCancellationAsync__TSource__3__7(Type TSource) => + private static MethodInfo AverageAwaitWithCancellationAsync__TSource__3__7(Type TSource) => (s_AverageAwaitWithCancellationAsync__TSource__3__7 ?? (s_AverageAwaitWithCancellationAsync__TSource__3__7 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -878,7 +878,7 @@ public static ValueTask AverageAwaitWithCancellationAsync(this private static MethodInfo? s_AverageAwaitWithCancellationAsync__TSource__3__8; - private static MethodInfo? AverageAwaitWithCancellationAsync__TSource__3__8(Type TSource) => + private static MethodInfo AverageAwaitWithCancellationAsync__TSource__3__8(Type TSource) => (s_AverageAwaitWithCancellationAsync__TSource__3__8 ?? (s_AverageAwaitWithCancellationAsync__TSource__3__8 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -894,7 +894,7 @@ public static ValueTask AverageAwaitWithCancellationAsync(this private static MethodInfo? s_AverageAwaitWithCancellationAsync__TSource__3__9; - private static MethodInfo? AverageAwaitWithCancellationAsync__TSource__3__9(Type TSource) => + private static MethodInfo AverageAwaitWithCancellationAsync__TSource__3__9(Type TSource) => (s_AverageAwaitWithCancellationAsync__TSource__3__9 ?? (s_AverageAwaitWithCancellationAsync__TSource__3__9 = new Func, Expression>>, CancellationToken, ValueTask>(AverageAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -910,7 +910,7 @@ public static ValueTask AverageAwaitWithCancellationAsync(this private static MethodInfo? s_Cast__TResult__1__0; - private static MethodInfo? Cast__TResult__1__0(Type TResult) => + private static MethodInfo Cast__TResult__1__0(Type TResult) => (s_Cast__TResult__1__0 ?? (s_Cast__TResult__1__0 = new Func, IAsyncQueryable>(Cast).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TResult); @@ -924,7 +924,7 @@ public static IAsyncQueryable Cast(this IAsyncQueryable + private static MethodInfo Concat__TSource__2__0(Type TSource) => (s_Concat__TSource__2__0 ?? (s_Concat__TSource__2__0 = new Func, IAsyncEnumerable, IAsyncQueryable>(Concat).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -940,7 +940,7 @@ public static IAsyncQueryable Concat(this IAsyncQueryable + private static MethodInfo ContainsAsync__TSource__3__0(Type TSource) => (s_ContainsAsync__TSource__3__0 ?? (s_ContainsAsync__TSource__3__0 = new Func, object, CancellationToken, ValueTask>(ContainsAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -954,7 +954,7 @@ public static ValueTask ContainsAsync(this IAsyncQueryable + private static MethodInfo ContainsAsync__TSource__4__0(Type TSource) => (s_ContainsAsync__TSource__4__0 ?? (s_ContainsAsync__TSource__4__0 = new Func, object, IEqualityComparer, CancellationToken, ValueTask>(ContainsAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -968,7 +968,7 @@ public static ValueTask ContainsAsync(this IAsyncQueryable + private static MethodInfo CountAsync__TSource__2__0(Type TSource) => (s_CountAsync__TSource__2__0 ?? (s_CountAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(CountAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -982,7 +982,7 @@ public static ValueTask CountAsync(this IAsyncQueryable s private static MethodInfo? s_CountAsync__TSource__3__0; - private static MethodInfo? CountAsync__TSource__3__0(Type TSource) => + private static MethodInfo CountAsync__TSource__3__0(Type TSource) => (s_CountAsync__TSource__3__0 ?? (s_CountAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(CountAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -998,7 +998,7 @@ public static ValueTask CountAsync(this IAsyncQueryable s private static MethodInfo? s_CountAwaitAsync__TSource__3__0; - private static MethodInfo? CountAwaitAsync__TSource__3__0(Type TSource) => + private static MethodInfo CountAwaitAsync__TSource__3__0(Type TSource) => (s_CountAwaitAsync__TSource__3__0 ?? (s_CountAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(CountAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1014,7 +1014,7 @@ public static ValueTask CountAwaitAsync(this IAsyncQueryable + private static MethodInfo CountAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_CountAwaitWithCancellationAsync__TSource__3__0 ?? (s_CountAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(CountAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1030,7 +1030,7 @@ public static ValueTask CountAwaitWithCancellationAsync(this IAsyn private static MethodInfo? s_DefaultIfEmpty__TSource__1__0; - private static MethodInfo? DefaultIfEmpty__TSource__1__0(Type TSource) => + private static MethodInfo DefaultIfEmpty__TSource__1__0(Type TSource) => (s_DefaultIfEmpty__TSource__1__0 ?? (s_DefaultIfEmpty__TSource__1__0 = new Func, IAsyncQueryable>(DefaultIfEmpty).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1044,7 +1044,7 @@ public static IAsyncQueryable DefaultIfEmpty(this IAsyncQuerya private static MethodInfo? s_DefaultIfEmpty__TSource__2__0; - private static MethodInfo? DefaultIfEmpty__TSource__2__0(Type TSource) => + private static MethodInfo DefaultIfEmpty__TSource__2__0(Type TSource) => (s_DefaultIfEmpty__TSource__2__0 ?? (s_DefaultIfEmpty__TSource__2__0 = new Func, object, IAsyncQueryable>(DefaultIfEmpty).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1058,7 +1058,7 @@ public static IAsyncQueryable DefaultIfEmpty(this IAsyncQuerya private static MethodInfo? s_Distinct__TSource__1__0; - private static MethodInfo? Distinct__TSource__1__0(Type TSource) => + private static MethodInfo Distinct__TSource__1__0(Type TSource) => (s_Distinct__TSource__1__0 ?? (s_Distinct__TSource__1__0 = new Func, IAsyncQueryable>(Distinct).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1072,7 +1072,7 @@ public static IAsyncQueryable Distinct(this IAsyncQueryable + private static MethodInfo Distinct__TSource__2__0(Type TSource) => (s_Distinct__TSource__2__0 ?? (s_Distinct__TSource__2__0 = new Func, IEqualityComparer, IAsyncQueryable>(Distinct).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1086,7 +1086,7 @@ public static IAsyncQueryable Distinct(this IAsyncQueryable + private static MethodInfo ElementAtAsync__TSource__3__0(Type TSource) => (s_ElementAtAsync__TSource__3__0 ?? (s_ElementAtAsync__TSource__3__0 = new Func, int, CancellationToken, ValueTask>(ElementAtAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1100,7 +1100,7 @@ public static ValueTask ElementAtAsync(this IAsyncQueryable + private static MethodInfo ElementAtOrDefaultAsync__TSource__3__0(Type TSource) => (s_ElementAtOrDefaultAsync__TSource__3__0 ?? (s_ElementAtOrDefaultAsync__TSource__3__0 = new Func, int, CancellationToken, ValueTask>(ElementAtOrDefaultAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1114,7 +1114,7 @@ public static ValueTask ElementAtAsync(this IAsyncQueryable + private static MethodInfo Except__TSource__2__0(Type TSource) => (s_Except__TSource__2__0 ?? (s_Except__TSource__2__0 = new Func, IAsyncEnumerable, IAsyncQueryable>(Except).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1130,7 +1130,7 @@ public static IAsyncQueryable Except(this IAsyncQueryable + private static MethodInfo Except__TSource__3__0(Type TSource) => (s_Except__TSource__3__0 ?? (s_Except__TSource__3__0 = new Func, IAsyncEnumerable, IEqualityComparer, IAsyncQueryable>(Except).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1146,7 +1146,7 @@ public static IAsyncQueryable Except(this IAsyncQueryable + private static MethodInfo FirstAsync__TSource__2__0(Type TSource) => (s_FirstAsync__TSource__2__0 ?? (s_FirstAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(FirstAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1160,7 +1160,7 @@ public static ValueTask FirstAsync(this IAsyncQueryable + private static MethodInfo FirstAsync__TSource__3__0(Type TSource) => (s_FirstAsync__TSource__3__0 ?? (s_FirstAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(FirstAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1176,7 +1176,7 @@ public static ValueTask FirstAsync(this IAsyncQueryable + private static MethodInfo FirstAwaitAsync__TSource__3__0(Type TSource) => (s_FirstAwaitAsync__TSource__3__0 ?? (s_FirstAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(FirstAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1192,7 +1192,7 @@ public static ValueTask FirstAwaitAsync(this IAsyncQueryable + private static MethodInfo FirstAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_FirstAwaitWithCancellationAsync__TSource__3__0 ?? (s_FirstAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(FirstAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1208,7 +1208,7 @@ public static ValueTask FirstAwaitWithCancellationAsync(this I private static MethodInfo? s_FirstOrDefaultAsync__TSource__2__0; - private static MethodInfo? FirstOrDefaultAsync__TSource__2__0(Type TSource) => + private static MethodInfo FirstOrDefaultAsync__TSource__2__0(Type TSource) => (s_FirstOrDefaultAsync__TSource__2__0 ?? (s_FirstOrDefaultAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(FirstOrDefaultAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1222,7 +1222,7 @@ public static ValueTask FirstAwaitWithCancellationAsync(this I private static MethodInfo? s_FirstOrDefaultAsync__TSource__3__0; - private static MethodInfo? FirstOrDefaultAsync__TSource__3__0(Type TSource) => + private static MethodInfo FirstOrDefaultAsync__TSource__3__0(Type TSource) => (s_FirstOrDefaultAsync__TSource__3__0 ?? (s_FirstOrDefaultAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(FirstOrDefaultAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1238,7 +1238,7 @@ public static ValueTask FirstAwaitWithCancellationAsync(this I private static MethodInfo? s_FirstOrDefaultAwaitAsync__TSource__3__0; - private static MethodInfo? FirstOrDefaultAwaitAsync__TSource__3__0(Type TSource) => + private static MethodInfo FirstOrDefaultAwaitAsync__TSource__3__0(Type TSource) => (s_FirstOrDefaultAwaitAsync__TSource__3__0 ?? (s_FirstOrDefaultAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(FirstOrDefaultAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1254,7 +1254,7 @@ public static ValueTask FirstAwaitWithCancellationAsync(this I private static MethodInfo? s_FirstOrDefaultAwaitWithCancellationAsync__TSource__3__0; - private static MethodInfo? FirstOrDefaultAwaitWithCancellationAsync__TSource__3__0(Type TSource) => + private static MethodInfo FirstOrDefaultAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_FirstOrDefaultAwaitWithCancellationAsync__TSource__3__0 ?? (s_FirstOrDefaultAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(FirstOrDefaultAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1270,7 +1270,7 @@ public static ValueTask FirstAwaitWithCancellationAsync(this I private static MethodInfo? s_GroupBy__TSource_TKey__2__0; - private static MethodInfo? GroupBy__TSource_TKey__2__0(Type TSource, Type TKey) => + private static MethodInfo GroupBy__TSource_TKey__2__0(Type TSource, Type TKey) => (s_GroupBy__TSource_TKey__2__0 ?? (s_GroupBy__TSource_TKey__2__0 = new Func, Expression>, IAsyncQueryable>>(GroupBy).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -1286,7 +1286,7 @@ public static IAsyncQueryable> GroupBy + private static MethodInfo GroupBy__TSource_TKey__3__0(Type TSource, Type TKey) => (s_GroupBy__TSource_TKey__3__0 ?? (s_GroupBy__TSource_TKey__3__0 = new Func, Expression>, IEqualityComparer, IAsyncQueryable>>(GroupBy).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -1302,7 +1302,7 @@ public static IAsyncQueryable> GroupBy + private static MethodInfo GroupBy__TSource_TKey_TResult__3__0(Type TSource, Type TKey, Type TResult) => (s_GroupBy__TSource_TKey_TResult__3__0 ?? (s_GroupBy__TSource_TKey_TResult__3__0 = new Func, Expression>, Expression, object>>, IAsyncQueryable>(GroupBy).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TResult); @@ -1320,7 +1320,7 @@ public static IAsyncQueryable GroupBy(this IAsy private static MethodInfo? s_GroupBy__TSource_TKey_TElement__3__0; - private static MethodInfo? GroupBy__TSource_TKey_TElement__3__0(Type TSource, Type TKey, Type TElement) => + private static MethodInfo GroupBy__TSource_TKey_TElement__3__0(Type TSource, Type TKey, Type TElement) => (s_GroupBy__TSource_TKey_TElement__3__0 ?? (s_GroupBy__TSource_TKey_TElement__3__0 = new Func, Expression>, Expression>, IAsyncQueryable>>(GroupBy).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -1338,7 +1338,7 @@ public static IAsyncQueryable> GroupBy + private static MethodInfo GroupBy__TSource_TKey_TResult__4__0(Type TSource, Type TKey, Type TResult) => (s_GroupBy__TSource_TKey_TResult__4__0 ?? (s_GroupBy__TSource_TKey_TResult__4__0 = new Func, Expression>, Expression, object>>, IEqualityComparer, IAsyncQueryable>(GroupBy).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TResult); @@ -1356,7 +1356,7 @@ public static IAsyncQueryable GroupBy(this IAsy private static MethodInfo? s_GroupBy__TSource_TKey_TElement__4__0; - private static MethodInfo? GroupBy__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => + private static MethodInfo GroupBy__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => (s_GroupBy__TSource_TKey_TElement__4__0 ?? (s_GroupBy__TSource_TKey_TElement__4__0 = new Func, Expression>, Expression>, IEqualityComparer, IAsyncQueryable>>(GroupBy).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -1374,7 +1374,7 @@ public static IAsyncQueryable> GroupBy + private static MethodInfo GroupBy__TSource_TKey_TElement_TResult__4__0(Type TSource, Type TKey, Type TElement, Type TResult) => (s_GroupBy__TSource_TKey_TElement_TResult__4__0 ?? (s_GroupBy__TSource_TKey_TElement_TResult__4__0 = new Func, Expression>, Expression>, Expression, object>>, IAsyncQueryable>(GroupBy).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement, TResult); @@ -1394,7 +1394,7 @@ public static IAsyncQueryable GroupBy private static MethodInfo? s_GroupBy__TSource_TKey_TElement_TResult__5__0; - private static MethodInfo? GroupBy__TSource_TKey_TElement_TResult__5__0(Type TSource, Type TKey, Type TElement, Type TResult) => + private static MethodInfo GroupBy__TSource_TKey_TElement_TResult__5__0(Type TSource, Type TKey, Type TElement, Type TResult) => (s_GroupBy__TSource_TKey_TElement_TResult__5__0 ?? (s_GroupBy__TSource_TKey_TElement_TResult__5__0 = new Func, Expression>, Expression>, Expression, object>>, IEqualityComparer, IAsyncQueryable>(GroupBy).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement, TResult); @@ -1414,7 +1414,7 @@ public static IAsyncQueryable GroupBy private static MethodInfo? s_GroupByAwait__TSource_TKey__2__0; - private static MethodInfo? GroupByAwait__TSource_TKey__2__0(Type TSource, Type TKey) => + private static MethodInfo GroupByAwait__TSource_TKey__2__0(Type TSource, Type TKey) => (s_GroupByAwait__TSource_TKey__2__0 ?? (s_GroupByAwait__TSource_TKey__2__0 = new Func, Expression>>, IAsyncQueryable>>(GroupByAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -1430,7 +1430,7 @@ public static IAsyncQueryable> GroupByAwait + private static MethodInfo GroupByAwait__TSource_TKey__3__0(Type TSource, Type TKey) => (s_GroupByAwait__TSource_TKey__3__0 ?? (s_GroupByAwait__TSource_TKey__3__0 = new Func, Expression>>, IEqualityComparer, IAsyncQueryable>>(GroupByAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -1446,7 +1446,7 @@ public static IAsyncQueryable> GroupByAwait + private static MethodInfo GroupByAwait__TSource_TKey_TResult__3__0(Type TSource, Type TKey, Type TResult) => (s_GroupByAwait__TSource_TKey_TResult__3__0 ?? (s_GroupByAwait__TSource_TKey_TResult__3__0 = new Func, Expression>>, Expression, ValueTask>>, IAsyncQueryable>(GroupByAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TResult); @@ -1464,7 +1464,7 @@ public static IAsyncQueryable GroupByAwait(this private static MethodInfo? s_GroupByAwait__TSource_TKey_TElement__3__0; - private static MethodInfo? GroupByAwait__TSource_TKey_TElement__3__0(Type TSource, Type TKey, Type TElement) => + private static MethodInfo GroupByAwait__TSource_TKey_TElement__3__0(Type TSource, Type TKey, Type TElement) => (s_GroupByAwait__TSource_TKey_TElement__3__0 ?? (s_GroupByAwait__TSource_TKey_TElement__3__0 = new Func, Expression>>, Expression>>, IAsyncQueryable>>(GroupByAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -1482,7 +1482,7 @@ public static IAsyncQueryable> GroupByAwait + private static MethodInfo GroupByAwait__TSource_TKey_TResult__4__0(Type TSource, Type TKey, Type TResult) => (s_GroupByAwait__TSource_TKey_TResult__4__0 ?? (s_GroupByAwait__TSource_TKey_TResult__4__0 = new Func, Expression>>, Expression, ValueTask>>, IEqualityComparer, IAsyncQueryable>(GroupByAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TResult); @@ -1500,7 +1500,7 @@ public static IAsyncQueryable GroupByAwait(this private static MethodInfo? s_GroupByAwait__TSource_TKey_TElement__4__0; - private static MethodInfo? GroupByAwait__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => + private static MethodInfo GroupByAwait__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => (s_GroupByAwait__TSource_TKey_TElement__4__0 ?? (s_GroupByAwait__TSource_TKey_TElement__4__0 = new Func, Expression>>, Expression>>, IEqualityComparer, IAsyncQueryable>>(GroupByAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -1518,7 +1518,7 @@ public static IAsyncQueryable> GroupByAwait + private static MethodInfo GroupByAwait__TSource_TKey_TElement_TResult__4__0(Type TSource, Type TKey, Type TElement, Type TResult) => (s_GroupByAwait__TSource_TKey_TElement_TResult__4__0 ?? (s_GroupByAwait__TSource_TKey_TElement_TResult__4__0 = new Func, Expression>>, Expression>>, Expression, ValueTask>>, IAsyncQueryable>(GroupByAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement, TResult); @@ -1538,7 +1538,7 @@ public static IAsyncQueryable GroupByAwait + private static MethodInfo GroupByAwait__TSource_TKey_TElement_TResult__5__0(Type TSource, Type TKey, Type TElement, Type TResult) => (s_GroupByAwait__TSource_TKey_TElement_TResult__5__0 ?? (s_GroupByAwait__TSource_TKey_TElement_TResult__5__0 = new Func, Expression>>, Expression>>, Expression, ValueTask>>, IEqualityComparer, IAsyncQueryable>(GroupByAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement, TResult); @@ -1558,7 +1558,7 @@ public static IAsyncQueryable GroupByAwait + private static MethodInfo GroupByAwaitWithCancellation__TSource_TKey__2__0(Type TSource, Type TKey) => (s_GroupByAwaitWithCancellation__TSource_TKey__2__0 ?? (s_GroupByAwaitWithCancellation__TSource_TKey__2__0 = new Func, Expression>>, IAsyncQueryable>>(GroupByAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -1574,7 +1574,7 @@ public static IAsyncQueryable> GroupByAwaitWithCan private static MethodInfo? s_GroupByAwaitWithCancellation__TSource_TKey__3__0; - private static MethodInfo? GroupByAwaitWithCancellation__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo GroupByAwaitWithCancellation__TSource_TKey__3__0(Type TSource, Type TKey) => (s_GroupByAwaitWithCancellation__TSource_TKey__3__0 ?? (s_GroupByAwaitWithCancellation__TSource_TKey__3__0 = new Func, Expression>>, IEqualityComparer, IAsyncQueryable>>(GroupByAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -1590,7 +1590,7 @@ public static IAsyncQueryable> GroupByAwaitWithCan private static MethodInfo? s_GroupByAwaitWithCancellation__TSource_TKey_TResult__3__0; - private static MethodInfo? GroupByAwaitWithCancellation__TSource_TKey_TResult__3__0(Type TSource, Type TKey, Type TResult) => + private static MethodInfo GroupByAwaitWithCancellation__TSource_TKey_TResult__3__0(Type TSource, Type TKey, Type TResult) => (s_GroupByAwaitWithCancellation__TSource_TKey_TResult__3__0 ?? (s_GroupByAwaitWithCancellation__TSource_TKey_TResult__3__0 = new Func, Expression>>, Expression, CancellationToken, ValueTask>>, IAsyncQueryable>(GroupByAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TResult); @@ -1608,7 +1608,7 @@ public static IAsyncQueryable GroupByAwaitWithCancellation + private static MethodInfo GroupByAwaitWithCancellation__TSource_TKey_TElement__3__0(Type TSource, Type TKey, Type TElement) => (s_GroupByAwaitWithCancellation__TSource_TKey_TElement__3__0 ?? (s_GroupByAwaitWithCancellation__TSource_TKey_TElement__3__0 = new Func, Expression>>, Expression>>, IAsyncQueryable>>(GroupByAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -1626,7 +1626,7 @@ public static IAsyncQueryable> GroupByAwaitWithCa private static MethodInfo? s_GroupByAwaitWithCancellation__TSource_TKey_TResult__4__0; - private static MethodInfo? GroupByAwaitWithCancellation__TSource_TKey_TResult__4__0(Type TSource, Type TKey, Type TResult) => + private static MethodInfo GroupByAwaitWithCancellation__TSource_TKey_TResult__4__0(Type TSource, Type TKey, Type TResult) => (s_GroupByAwaitWithCancellation__TSource_TKey_TResult__4__0 ?? (s_GroupByAwaitWithCancellation__TSource_TKey_TResult__4__0 = new Func, Expression>>, Expression, CancellationToken, ValueTask>>, IEqualityComparer, IAsyncQueryable>(GroupByAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TResult); @@ -1644,7 +1644,7 @@ public static IAsyncQueryable GroupByAwaitWithCancellation + private static MethodInfo GroupByAwaitWithCancellation__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => (s_GroupByAwaitWithCancellation__TSource_TKey_TElement__4__0 ?? (s_GroupByAwaitWithCancellation__TSource_TKey_TElement__4__0 = new Func, Expression>>, Expression>>, IEqualityComparer, IAsyncQueryable>>(GroupByAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -1662,7 +1662,7 @@ public static IAsyncQueryable> GroupByAwaitWithCa private static MethodInfo? s_GroupByAwaitWithCancellation__TSource_TKey_TElement_TResult__4__0; - private static MethodInfo? GroupByAwaitWithCancellation__TSource_TKey_TElement_TResult__4__0(Type TSource, Type TKey, Type TElement, Type TResult) => + private static MethodInfo GroupByAwaitWithCancellation__TSource_TKey_TElement_TResult__4__0(Type TSource, Type TKey, Type TElement, Type TResult) => (s_GroupByAwaitWithCancellation__TSource_TKey_TElement_TResult__4__0 ?? (s_GroupByAwaitWithCancellation__TSource_TKey_TElement_TResult__4__0 = new Func, Expression>>, Expression>>, Expression, CancellationToken, ValueTask>>, IAsyncQueryable>(GroupByAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement, TResult); @@ -1682,7 +1682,7 @@ public static IAsyncQueryable GroupByAwaitWithCancellation + private static MethodInfo GroupByAwaitWithCancellation__TSource_TKey_TElement_TResult__5__0(Type TSource, Type TKey, Type TElement, Type TResult) => (s_GroupByAwaitWithCancellation__TSource_TKey_TElement_TResult__5__0 ?? (s_GroupByAwaitWithCancellation__TSource_TKey_TElement_TResult__5__0 = new Func, Expression>>, Expression>>, Expression, CancellationToken, ValueTask>>, IEqualityComparer, IAsyncQueryable>(GroupByAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement, TResult); @@ -1702,7 +1702,7 @@ public static IAsyncQueryable GroupByAwaitWithCancellation + private static MethodInfo GroupJoin__TOuter_TInner_TKey_TResult__5__0(Type TOuter, Type TInner, Type TKey, Type TResult) => (s_GroupJoin__TOuter_TInner_TKey_TResult__5__0 ?? (s_GroupJoin__TOuter_TInner_TKey_TResult__5__0 = new Func, IAsyncEnumerable, Expression>, Expression>, Expression, object>>, IAsyncQueryable>(GroupJoin).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TOuter, TInner, TKey, TResult); @@ -1724,7 +1724,7 @@ public static IAsyncQueryable GroupJoin( private static MethodInfo? s_GroupJoin__TOuter_TInner_TKey_TResult__6__0; - private static MethodInfo? GroupJoin__TOuter_TInner_TKey_TResult__6__0(Type TOuter, Type TInner, Type TKey, Type TResult) => + private static MethodInfo GroupJoin__TOuter_TInner_TKey_TResult__6__0(Type TOuter, Type TInner, Type TKey, Type TResult) => (s_GroupJoin__TOuter_TInner_TKey_TResult__6__0 ?? (s_GroupJoin__TOuter_TInner_TKey_TResult__6__0 = new Func, IAsyncEnumerable, Expression>, Expression>, Expression, object>>, IEqualityComparer, IAsyncQueryable>(GroupJoin).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TOuter, TInner, TKey, TResult); @@ -1746,7 +1746,7 @@ public static IAsyncQueryable GroupJoin( private static MethodInfo? s_GroupJoinAwait__TOuter_TInner_TKey_TResult__5__0; - private static MethodInfo? GroupJoinAwait__TOuter_TInner_TKey_TResult__5__0(Type TOuter, Type TInner, Type TKey, Type TResult) => + private static MethodInfo GroupJoinAwait__TOuter_TInner_TKey_TResult__5__0(Type TOuter, Type TInner, Type TKey, Type TResult) => (s_GroupJoinAwait__TOuter_TInner_TKey_TResult__5__0 ?? (s_GroupJoinAwait__TOuter_TInner_TKey_TResult__5__0 = new Func, IAsyncEnumerable, Expression>>, Expression>>, Expression, ValueTask>>, IAsyncQueryable>(GroupJoinAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TOuter, TInner, TKey, TResult); @@ -1768,7 +1768,7 @@ public static IAsyncQueryable GroupJoinAwait + private static MethodInfo GroupJoinAwait__TOuter_TInner_TKey_TResult__6__0(Type TOuter, Type TInner, Type TKey, Type TResult) => (s_GroupJoinAwait__TOuter_TInner_TKey_TResult__6__0 ?? (s_GroupJoinAwait__TOuter_TInner_TKey_TResult__6__0 = new Func, IAsyncEnumerable, Expression>>, Expression>>, Expression, ValueTask>>, IEqualityComparer, IAsyncQueryable>(GroupJoinAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TOuter, TInner, TKey, TResult); @@ -1790,7 +1790,7 @@ public static IAsyncQueryable GroupJoinAwait + private static MethodInfo GroupJoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__5__0(Type TOuter, Type TInner, Type TKey, Type TResult) => (s_GroupJoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__5__0 ?? (s_GroupJoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__5__0 = new Func, IAsyncEnumerable, Expression>>, Expression>>, Expression, CancellationToken, ValueTask>>, IAsyncQueryable>(GroupJoinAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TOuter, TInner, TKey, TResult); @@ -1812,7 +1812,7 @@ public static IAsyncQueryable GroupJoinAwaitWithCancellation + private static MethodInfo GroupJoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__6__0(Type TOuter, Type TInner, Type TKey, Type TResult) => (s_GroupJoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__6__0 ?? (s_GroupJoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__6__0 = new Func, IAsyncEnumerable, Expression>>, Expression>>, Expression, CancellationToken, ValueTask>>, IEqualityComparer, IAsyncQueryable>(GroupJoinAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TOuter, TInner, TKey, TResult); @@ -1834,7 +1834,7 @@ public static IAsyncQueryable GroupJoinAwaitWithCancellation + private static MethodInfo Intersect__TSource__2__0(Type TSource) => (s_Intersect__TSource__2__0 ?? (s_Intersect__TSource__2__0 = new Func, IAsyncEnumerable, IAsyncQueryable>(Intersect).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1850,7 +1850,7 @@ public static IAsyncQueryable Intersect(this IAsyncQueryable + private static MethodInfo Intersect__TSource__3__0(Type TSource) => (s_Intersect__TSource__3__0 ?? (s_Intersect__TSource__3__0 = new Func, IAsyncEnumerable, IEqualityComparer, IAsyncQueryable>(Intersect).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -1866,7 +1866,7 @@ public static IAsyncQueryable Intersect(this IAsyncQueryable + private static MethodInfo Join__TOuter_TInner_TKey_TResult__5__0(Type TOuter, Type TInner, Type TKey, Type TResult) => (s_Join__TOuter_TInner_TKey_TResult__5__0 ?? (s_Join__TOuter_TInner_TKey_TResult__5__0 = new Func, IAsyncEnumerable, Expression>, Expression>, Expression>, IAsyncQueryable>(Join).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TOuter, TInner, TKey, TResult); @@ -1888,7 +1888,7 @@ public static IAsyncQueryable Join(this private static MethodInfo? s_Join__TOuter_TInner_TKey_TResult__6__0; - private static MethodInfo? Join__TOuter_TInner_TKey_TResult__6__0(Type TOuter, Type TInner, Type TKey, Type TResult) => + private static MethodInfo Join__TOuter_TInner_TKey_TResult__6__0(Type TOuter, Type TInner, Type TKey, Type TResult) => (s_Join__TOuter_TInner_TKey_TResult__6__0 ?? (s_Join__TOuter_TInner_TKey_TResult__6__0 = new Func, IAsyncEnumerable, Expression>, Expression>, Expression>, IEqualityComparer, IAsyncQueryable>(Join).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TOuter, TInner, TKey, TResult); @@ -1910,7 +1910,7 @@ public static IAsyncQueryable Join(this private static MethodInfo? s_JoinAwait__TOuter_TInner_TKey_TResult__5__0; - private static MethodInfo? JoinAwait__TOuter_TInner_TKey_TResult__5__0(Type TOuter, Type TInner, Type TKey, Type TResult) => + private static MethodInfo JoinAwait__TOuter_TInner_TKey_TResult__5__0(Type TOuter, Type TInner, Type TKey, Type TResult) => (s_JoinAwait__TOuter_TInner_TKey_TResult__5__0 ?? (s_JoinAwait__TOuter_TInner_TKey_TResult__5__0 = new Func, IAsyncEnumerable, Expression>>, Expression>>, Expression>>, IAsyncQueryable>(JoinAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TOuter, TInner, TKey, TResult); @@ -1932,7 +1932,7 @@ public static IAsyncQueryable JoinAwait( private static MethodInfo? s_JoinAwait__TOuter_TInner_TKey_TResult__6__0; - private static MethodInfo? JoinAwait__TOuter_TInner_TKey_TResult__6__0(Type TOuter, Type TInner, Type TKey, Type TResult) => + private static MethodInfo JoinAwait__TOuter_TInner_TKey_TResult__6__0(Type TOuter, Type TInner, Type TKey, Type TResult) => (s_JoinAwait__TOuter_TInner_TKey_TResult__6__0 ?? (s_JoinAwait__TOuter_TInner_TKey_TResult__6__0 = new Func, IAsyncEnumerable, Expression>>, Expression>>, Expression>>, IEqualityComparer, IAsyncQueryable>(JoinAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TOuter, TInner, TKey, TResult); @@ -1954,7 +1954,7 @@ public static IAsyncQueryable JoinAwait( private static MethodInfo? s_JoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__5__0; - private static MethodInfo? JoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__5__0(Type TOuter, Type TInner, Type TKey, Type TResult) => + private static MethodInfo JoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__5__0(Type TOuter, Type TInner, Type TKey, Type TResult) => (s_JoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__5__0 ?? (s_JoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__5__0 = new Func, IAsyncEnumerable, Expression>>, Expression>>, Expression>>, IAsyncQueryable>(JoinAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TOuter, TInner, TKey, TResult); @@ -1976,7 +1976,7 @@ public static IAsyncQueryable JoinAwaitWithCancellation + private static MethodInfo JoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__6__0(Type TOuter, Type TInner, Type TKey, Type TResult) => (s_JoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__6__0 ?? (s_JoinAwaitWithCancellation__TOuter_TInner_TKey_TResult__6__0 = new Func, IAsyncEnumerable, Expression>>, Expression>>, Expression>>, IEqualityComparer, IAsyncQueryable>(JoinAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TOuter, TInner, TKey, TResult); @@ -1998,7 +1998,7 @@ public static IAsyncQueryable JoinAwaitWithCancellation + private static MethodInfo LastAsync__TSource__2__0(Type TSource) => (s_LastAsync__TSource__2__0 ?? (s_LastAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(LastAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2012,7 +2012,7 @@ public static ValueTask LastAsync(this IAsyncQueryable + private static MethodInfo LastAsync__TSource__3__0(Type TSource) => (s_LastAsync__TSource__3__0 ?? (s_LastAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(LastAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2028,7 +2028,7 @@ public static ValueTask LastAsync(this IAsyncQueryable + private static MethodInfo LastAwaitAsync__TSource__3__0(Type TSource) => (s_LastAwaitAsync__TSource__3__0 ?? (s_LastAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(LastAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2044,7 +2044,7 @@ public static ValueTask LastAwaitAsync(this IAsyncQueryable + private static MethodInfo LastAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_LastAwaitWithCancellationAsync__TSource__3__0 ?? (s_LastAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(LastAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2060,7 +2060,7 @@ public static ValueTask LastAwaitWithCancellationAsync(this IA private static MethodInfo? s_LastOrDefaultAsync__TSource__2__0; - private static MethodInfo? LastOrDefaultAsync__TSource__2__0(Type TSource) => + private static MethodInfo LastOrDefaultAsync__TSource__2__0(Type TSource) => (s_LastOrDefaultAsync__TSource__2__0 ?? (s_LastOrDefaultAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(LastOrDefaultAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2074,7 +2074,7 @@ public static ValueTask LastAwaitWithCancellationAsync(this IA private static MethodInfo? s_LastOrDefaultAsync__TSource__3__0; - private static MethodInfo? LastOrDefaultAsync__TSource__3__0(Type TSource) => + private static MethodInfo LastOrDefaultAsync__TSource__3__0(Type TSource) => (s_LastOrDefaultAsync__TSource__3__0 ?? (s_LastOrDefaultAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(LastOrDefaultAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2090,7 +2090,7 @@ public static ValueTask LastAwaitWithCancellationAsync(this IA private static MethodInfo? s_LastOrDefaultAwaitAsync__TSource__3__0; - private static MethodInfo? LastOrDefaultAwaitAsync__TSource__3__0(Type TSource) => + private static MethodInfo LastOrDefaultAwaitAsync__TSource__3__0(Type TSource) => (s_LastOrDefaultAwaitAsync__TSource__3__0 ?? (s_LastOrDefaultAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(LastOrDefaultAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2106,7 +2106,7 @@ public static ValueTask LastAwaitWithCancellationAsync(this IA private static MethodInfo? s_LastOrDefaultAwaitWithCancellationAsync__TSource__3__0; - private static MethodInfo? LastOrDefaultAwaitWithCancellationAsync__TSource__3__0(Type TSource) => + private static MethodInfo LastOrDefaultAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_LastOrDefaultAwaitWithCancellationAsync__TSource__3__0 ?? (s_LastOrDefaultAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(LastOrDefaultAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2122,7 +2122,7 @@ public static ValueTask LastAwaitWithCancellationAsync(this IA private static MethodInfo? s_LongCountAsync__TSource__2__0; - private static MethodInfo? LongCountAsync__TSource__2__0(Type TSource) => + private static MethodInfo LongCountAsync__TSource__2__0(Type TSource) => (s_LongCountAsync__TSource__2__0 ?? (s_LongCountAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(LongCountAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2136,7 +2136,7 @@ public static ValueTask LongCountAsync(this IAsyncQueryable + private static MethodInfo LongCountAsync__TSource__3__0(Type TSource) => (s_LongCountAsync__TSource__3__0 ?? (s_LongCountAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(LongCountAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2152,7 +2152,7 @@ public static ValueTask LongCountAsync(this IAsyncQueryable + private static MethodInfo LongCountAwaitAsync__TSource__3__0(Type TSource) => (s_LongCountAwaitAsync__TSource__3__0 ?? (s_LongCountAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(LongCountAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2168,7 +2168,7 @@ public static ValueTask LongCountAwaitAsync(this IAsyncQueryable< private static MethodInfo? s_LongCountAwaitWithCancellationAsync__TSource__3__0; - private static MethodInfo? LongCountAwaitWithCancellationAsync__TSource__3__0(Type TSource) => + private static MethodInfo LongCountAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_LongCountAwaitWithCancellationAsync__TSource__3__0 ?? (s_LongCountAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(LongCountAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2184,7 +2184,7 @@ public static ValueTask LongCountAwaitWithCancellationAsync(this private static MethodInfo? s_MaxAsync__2__0; - private static MethodInfo? MaxAsync__2__0 => + private static MethodInfo MaxAsync__2__0 => (s_MaxAsync__2__0 ?? (s_MaxAsync__2__0 = new Func, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo())); @@ -2198,7 +2198,7 @@ public static ValueTask LongCountAwaitWithCancellationAsync(this private static MethodInfo? s_MaxAsync__2__1; - private static MethodInfo? MaxAsync__2__1 => + private static MethodInfo MaxAsync__2__1 => (s_MaxAsync__2__1 ?? (s_MaxAsync__2__1 = new Func, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo())); @@ -2212,7 +2212,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable source, private static MethodInfo? s_MaxAsync__2__2; - private static MethodInfo? MaxAsync__2__2 => + private static MethodInfo MaxAsync__2__2 => (s_MaxAsync__2__2 ?? (s_MaxAsync__2__2 = new Func, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo())); @@ -2226,7 +2226,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable source, private static MethodInfo? s_MaxAsync__2__3; - private static MethodInfo? MaxAsync__2__3 => + private static MethodInfo MaxAsync__2__3 => (s_MaxAsync__2__3 ?? (s_MaxAsync__2__3 = new Func, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo())); @@ -2240,7 +2240,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable source, Ca private static MethodInfo? s_MaxAsync__2__4; - private static MethodInfo? MaxAsync__2__4 => + private static MethodInfo MaxAsync__2__4 => (s_MaxAsync__2__4 ?? (s_MaxAsync__2__4 = new Func, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo())); @@ -2254,7 +2254,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable source, Ca private static MethodInfo? s_MaxAsync__2__5; - private static MethodInfo? MaxAsync__2__5 => + private static MethodInfo MaxAsync__2__5 => (s_MaxAsync__2__5 ?? (s_MaxAsync__2__5 = new Func, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo())); @@ -2268,7 +2268,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable source, Canc private static MethodInfo? s_MaxAsync__2__6; - private static MethodInfo? MaxAsync__2__6 => + private static MethodInfo MaxAsync__2__6 => (s_MaxAsync__2__6 ?? (s_MaxAsync__2__6 = new Func, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo())); @@ -2282,7 +2282,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable source, Canc private static MethodInfo? s_MaxAsync__2__7; - private static MethodInfo? MaxAsync__2__7 => + private static MethodInfo MaxAsync__2__7 => (s_MaxAsync__2__7 ?? (s_MaxAsync__2__7 = new Func, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo())); @@ -2296,7 +2296,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable source, Cancella private static MethodInfo? s_MaxAsync__2__8; - private static MethodInfo? MaxAsync__2__8 => + private static MethodInfo MaxAsync__2__8 => (s_MaxAsync__2__8 ?? (s_MaxAsync__2__8 = new Func, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo())); @@ -2310,7 +2310,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable source, Cancella private static MethodInfo? s_MaxAsync__2__9; - private static MethodInfo? MaxAsync__2__9 => + private static MethodInfo MaxAsync__2__9 => (s_MaxAsync__2__9 ?? (s_MaxAsync__2__9 = new Func, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo())); @@ -2324,7 +2324,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable source, Cancel private static MethodInfo? s_MaxAsync__TSource__2__0; - private static MethodInfo? MaxAsync__TSource__2__0(Type TSource) => + private static MethodInfo MaxAsync__TSource__2__0(Type TSource) => (s_MaxAsync__TSource__2__0 ?? (s_MaxAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2338,7 +2338,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable private static MethodInfo? s_MaxAsync__TSource__3__0; - private static MethodInfo? MaxAsync__TSource__3__0(Type TSource) => + private static MethodInfo MaxAsync__TSource__3__0(Type TSource) => (s_MaxAsync__TSource__3__0 ?? (s_MaxAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2354,7 +2354,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable private static MethodInfo? s_MaxAsync__TSource__3__1; - private static MethodInfo? MaxAsync__TSource__3__1(Type TSource) => + private static MethodInfo MaxAsync__TSource__3__1(Type TSource) => (s_MaxAsync__TSource__3__1 ?? (s_MaxAsync__TSource__3__1 = new Func, Expression>, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2370,7 +2370,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable private static MethodInfo? s_MaxAsync__TSource__3__2; - private static MethodInfo? MaxAsync__TSource__3__2(Type TSource) => + private static MethodInfo MaxAsync__TSource__3__2(Type TSource) => (s_MaxAsync__TSource__3__2 ?? (s_MaxAsync__TSource__3__2 = new Func, Expression>, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2386,7 +2386,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable private static MethodInfo? s_MaxAsync__TSource__3__3; - private static MethodInfo? MaxAsync__TSource__3__3(Type TSource) => + private static MethodInfo MaxAsync__TSource__3__3(Type TSource) => (s_MaxAsync__TSource__3__3 ?? (s_MaxAsync__TSource__3__3 = new Func, Expression>, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2402,7 +2402,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable private static MethodInfo? s_MaxAsync__TSource__3__4; - private static MethodInfo? MaxAsync__TSource__3__4(Type TSource) => + private static MethodInfo MaxAsync__TSource__3__4(Type TSource) => (s_MaxAsync__TSource__3__4 ?? (s_MaxAsync__TSource__3__4 = new Func, Expression>, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2418,7 +2418,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable private static MethodInfo? s_MaxAsync__TSource__3__5; - private static MethodInfo? MaxAsync__TSource__3__5(Type TSource) => + private static MethodInfo MaxAsync__TSource__3__5(Type TSource) => (s_MaxAsync__TSource__3__5 ?? (s_MaxAsync__TSource__3__5 = new Func, Expression>, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2434,7 +2434,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable s private static MethodInfo? s_MaxAsync__TSource__3__6; - private static MethodInfo? MaxAsync__TSource__3__6(Type TSource) => + private static MethodInfo MaxAsync__TSource__3__6(Type TSource) => (s_MaxAsync__TSource__3__6 ?? (s_MaxAsync__TSource__3__6 = new Func, Expression>, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2450,7 +2450,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable s private static MethodInfo? s_MaxAsync__TSource__3__7; - private static MethodInfo? MaxAsync__TSource__3__7(Type TSource) => + private static MethodInfo MaxAsync__TSource__3__7(Type TSource) => (s_MaxAsync__TSource__3__7 ?? (s_MaxAsync__TSource__3__7 = new Func, Expression>, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2466,7 +2466,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable sou private static MethodInfo? s_MaxAsync__TSource__3__8; - private static MethodInfo? MaxAsync__TSource__3__8(Type TSource) => + private static MethodInfo MaxAsync__TSource__3__8(Type TSource) => (s_MaxAsync__TSource__3__8 ?? (s_MaxAsync__TSource__3__8 = new Func, Expression>, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2482,7 +2482,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable sou private static MethodInfo? s_MaxAsync__TSource__3__9; - private static MethodInfo? MaxAsync__TSource__3__9(Type TSource) => + private static MethodInfo MaxAsync__TSource__3__9(Type TSource) => (s_MaxAsync__TSource__3__9 ?? (s_MaxAsync__TSource__3__9 = new Func, Expression>, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2498,7 +2498,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable so private static MethodInfo? s_MaxAsync__TSource_TResult__3__0; - private static MethodInfo? MaxAsync__TSource_TResult__3__0(Type TSource, Type TResult) => + private static MethodInfo MaxAsync__TSource_TResult__3__0(Type TSource, Type TResult) => (s_MaxAsync__TSource_TResult__3__0 ?? (s_MaxAsync__TSource_TResult__3__0 = new Func, Expression>, CancellationToken, ValueTask>(MaxAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -2514,7 +2514,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable private static MethodInfo? s_MaxAwaitAsync__TSource__3__0; - private static MethodInfo? MaxAwaitAsync__TSource__3__0(Type TSource) => + private static MethodInfo MaxAwaitAsync__TSource__3__0(Type TSource) => (s_MaxAwaitAsync__TSource__3__0 ?? (s_MaxAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2530,7 +2530,7 @@ public static ValueTask MaxAsync(this IAsyncQueryable private static MethodInfo? s_MaxAwaitAsync__TSource__3__1; - private static MethodInfo? MaxAwaitAsync__TSource__3__1(Type TSource) => + private static MethodInfo MaxAwaitAsync__TSource__3__1(Type TSource) => (s_MaxAwaitAsync__TSource__3__1 ?? (s_MaxAwaitAsync__TSource__3__1 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2546,7 +2546,7 @@ public static ValueTask MaxAwaitAsync(this IAsyncQueryable + private static MethodInfo MaxAwaitAsync__TSource__3__2(Type TSource) => (s_MaxAwaitAsync__TSource__3__2 ?? (s_MaxAwaitAsync__TSource__3__2 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2562,7 +2562,7 @@ public static ValueTask MaxAwaitAsync(this IAsyncQueryable + private static MethodInfo MaxAwaitAsync__TSource__3__3(Type TSource) => (s_MaxAwaitAsync__TSource__3__3 ?? (s_MaxAwaitAsync__TSource__3__3 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2578,7 +2578,7 @@ public static ValueTask MaxAwaitAsync(this IAsyncQueryable + private static MethodInfo MaxAwaitAsync__TSource__3__4(Type TSource) => (s_MaxAwaitAsync__TSource__3__4 ?? (s_MaxAwaitAsync__TSource__3__4 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2594,7 +2594,7 @@ public static ValueTask MaxAwaitAsync(this IAsyncQueryable + private static MethodInfo MaxAwaitAsync__TSource__3__5(Type TSource) => (s_MaxAwaitAsync__TSource__3__5 ?? (s_MaxAwaitAsync__TSource__3__5 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2610,7 +2610,7 @@ public static ValueTask MaxAwaitAsync(this IAsyncQueryable + private static MethodInfo MaxAwaitAsync__TSource__3__6(Type TSource) => (s_MaxAwaitAsync__TSource__3__6 ?? (s_MaxAwaitAsync__TSource__3__6 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2626,7 +2626,7 @@ public static ValueTask MaxAwaitAsync(this IAsyncQueryable + private static MethodInfo MaxAwaitAsync__TSource__3__7(Type TSource) => (s_MaxAwaitAsync__TSource__3__7 ?? (s_MaxAwaitAsync__TSource__3__7 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2642,7 +2642,7 @@ public static ValueTask MaxAwaitAsync(this IAsyncQueryable + private static MethodInfo MaxAwaitAsync__TSource__3__8(Type TSource) => (s_MaxAwaitAsync__TSource__3__8 ?? (s_MaxAwaitAsync__TSource__3__8 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2658,7 +2658,7 @@ public static ValueTask MaxAwaitAsync(this IAsyncQueryable + private static MethodInfo MaxAwaitAsync__TSource__3__9(Type TSource) => (s_MaxAwaitAsync__TSource__3__9 ?? (s_MaxAwaitAsync__TSource__3__9 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2674,7 +2674,7 @@ public static ValueTask MaxAwaitAsync(this IAsyncQueryable + private static MethodInfo MaxAwaitAsync__TSource_TResult__3__0(Type TSource, Type TResult) => (s_MaxAwaitAsync__TSource_TResult__3__0 ?? (s_MaxAwaitAsync__TSource_TResult__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -2690,7 +2690,7 @@ public static ValueTask MaxAwaitAsync(this IAsyncQuer private static MethodInfo? s_MaxAwaitWithCancellationAsync__TSource__3__0; - private static MethodInfo? MaxAwaitWithCancellationAsync__TSource__3__0(Type TSource) => + private static MethodInfo MaxAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_MaxAwaitWithCancellationAsync__TSource__3__0 ?? (s_MaxAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2706,7 +2706,7 @@ public static ValueTask MaxAwaitAsync(this IAsyncQuer private static MethodInfo? s_MaxAwaitWithCancellationAsync__TSource__3__1; - private static MethodInfo? MaxAwaitWithCancellationAsync__TSource__3__1(Type TSource) => + private static MethodInfo MaxAwaitWithCancellationAsync__TSource__3__1(Type TSource) => (s_MaxAwaitWithCancellationAsync__TSource__3__1 ?? (s_MaxAwaitWithCancellationAsync__TSource__3__1 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2722,7 +2722,7 @@ public static ValueTask MaxAwaitWithCancellationAsync(this IAs private static MethodInfo? s_MaxAwaitWithCancellationAsync__TSource__3__2; - private static MethodInfo? MaxAwaitWithCancellationAsync__TSource__3__2(Type TSource) => + private static MethodInfo MaxAwaitWithCancellationAsync__TSource__3__2(Type TSource) => (s_MaxAwaitWithCancellationAsync__TSource__3__2 ?? (s_MaxAwaitWithCancellationAsync__TSource__3__2 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2738,7 +2738,7 @@ public static ValueTask MaxAwaitWithCancellationAsync(this IAs private static MethodInfo? s_MaxAwaitWithCancellationAsync__TSource__3__3; - private static MethodInfo? MaxAwaitWithCancellationAsync__TSource__3__3(Type TSource) => + private static MethodInfo MaxAwaitWithCancellationAsync__TSource__3__3(Type TSource) => (s_MaxAwaitWithCancellationAsync__TSource__3__3 ?? (s_MaxAwaitWithCancellationAsync__TSource__3__3 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2754,7 +2754,7 @@ public static ValueTask MaxAwaitWithCancellationAsync(this IAsy private static MethodInfo? s_MaxAwaitWithCancellationAsync__TSource__3__4; - private static MethodInfo? MaxAwaitWithCancellationAsync__TSource__3__4(Type TSource) => + private static MethodInfo MaxAwaitWithCancellationAsync__TSource__3__4(Type TSource) => (s_MaxAwaitWithCancellationAsync__TSource__3__4 ?? (s_MaxAwaitWithCancellationAsync__TSource__3__4 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2770,7 +2770,7 @@ public static ValueTask MaxAwaitWithCancellationAsync(this IAsy private static MethodInfo? s_MaxAwaitWithCancellationAsync__TSource__3__5; - private static MethodInfo? MaxAwaitWithCancellationAsync__TSource__3__5(Type TSource) => + private static MethodInfo MaxAwaitWithCancellationAsync__TSource__3__5(Type TSource) => (s_MaxAwaitWithCancellationAsync__TSource__3__5 ?? (s_MaxAwaitWithCancellationAsync__TSource__3__5 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2786,7 +2786,7 @@ public static ValueTask MaxAwaitWithCancellationAsync(this IAsyn private static MethodInfo? s_MaxAwaitWithCancellationAsync__TSource__3__6; - private static MethodInfo? MaxAwaitWithCancellationAsync__TSource__3__6(Type TSource) => + private static MethodInfo MaxAwaitWithCancellationAsync__TSource__3__6(Type TSource) => (s_MaxAwaitWithCancellationAsync__TSource__3__6 ?? (s_MaxAwaitWithCancellationAsync__TSource__3__6 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2802,7 +2802,7 @@ public static ValueTask MaxAwaitWithCancellationAsync(this IAsyn private static MethodInfo? s_MaxAwaitWithCancellationAsync__TSource__3__7; - private static MethodInfo? MaxAwaitWithCancellationAsync__TSource__3__7(Type TSource) => + private static MethodInfo MaxAwaitWithCancellationAsync__TSource__3__7(Type TSource) => (s_MaxAwaitWithCancellationAsync__TSource__3__7 ?? (s_MaxAwaitWithCancellationAsync__TSource__3__7 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2818,7 +2818,7 @@ public static ValueTask MaxAwaitWithCancellationAsync(this IAsyncQ private static MethodInfo? s_MaxAwaitWithCancellationAsync__TSource__3__8; - private static MethodInfo? MaxAwaitWithCancellationAsync__TSource__3__8(Type TSource) => + private static MethodInfo MaxAwaitWithCancellationAsync__TSource__3__8(Type TSource) => (s_MaxAwaitWithCancellationAsync__TSource__3__8 ?? (s_MaxAwaitWithCancellationAsync__TSource__3__8 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2834,7 +2834,7 @@ public static ValueTask MaxAwaitWithCancellationAsync(this IAsyncQ private static MethodInfo? s_MaxAwaitWithCancellationAsync__TSource__3__9; - private static MethodInfo? MaxAwaitWithCancellationAsync__TSource__3__9(Type TSource) => + private static MethodInfo MaxAwaitWithCancellationAsync__TSource__3__9(Type TSource) => (s_MaxAwaitWithCancellationAsync__TSource__3__9 ?? (s_MaxAwaitWithCancellationAsync__TSource__3__9 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -2850,7 +2850,7 @@ public static ValueTask MaxAwaitWithCancellationAsync(this IAsync private static MethodInfo? s_MaxAwaitWithCancellationAsync__TSource_TResult__3__0; - private static MethodInfo? MaxAwaitWithCancellationAsync__TSource_TResult__3__0(Type TSource, Type TResult) => + private static MethodInfo MaxAwaitWithCancellationAsync__TSource_TResult__3__0(Type TSource, Type TResult) => (s_MaxAwaitWithCancellationAsync__TSource_TResult__3__0 ?? (s_MaxAwaitWithCancellationAsync__TSource_TResult__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(MaxAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -2866,7 +2866,7 @@ public static ValueTask MaxAwaitWithCancellationAsync private static MethodInfo? s_MinAsync__2__0; - private static MethodInfo? MinAsync__2__0 => + private static MethodInfo MinAsync__2__0 => (s_MinAsync__2__0 ?? (s_MinAsync__2__0 = new Func, CancellationToken, ValueTask>(MinAsync).GetMethodInfo())); @@ -2880,7 +2880,7 @@ public static ValueTask MaxAwaitWithCancellationAsync private static MethodInfo? s_MinAsync__2__1; - private static MethodInfo? MinAsync__2__1 => + private static MethodInfo MinAsync__2__1 => (s_MinAsync__2__1 ?? (s_MinAsync__2__1 = new Func, CancellationToken, ValueTask>(MinAsync).GetMethodInfo())); @@ -2894,7 +2894,7 @@ public static ValueTask MinAsync(this IAsyncQueryable source, private static MethodInfo? s_MinAsync__2__2; - private static MethodInfo? MinAsync__2__2 => + private static MethodInfo MinAsync__2__2 => (s_MinAsync__2__2 ?? (s_MinAsync__2__2 = new Func, CancellationToken, ValueTask>(MinAsync).GetMethodInfo())); @@ -2908,7 +2908,7 @@ public static ValueTask MinAsync(this IAsyncQueryable source, private static MethodInfo? s_MinAsync__2__3; - private static MethodInfo? MinAsync__2__3 => + private static MethodInfo MinAsync__2__3 => (s_MinAsync__2__3 ?? (s_MinAsync__2__3 = new Func, CancellationToken, ValueTask>(MinAsync).GetMethodInfo())); @@ -2922,7 +2922,7 @@ public static ValueTask MinAsync(this IAsyncQueryable source, Ca private static MethodInfo? s_MinAsync__2__4; - private static MethodInfo? MinAsync__2__4 => + private static MethodInfo MinAsync__2__4 => (s_MinAsync__2__4 ?? (s_MinAsync__2__4 = new Func, CancellationToken, ValueTask>(MinAsync).GetMethodInfo())); @@ -2936,7 +2936,7 @@ public static ValueTask MinAsync(this IAsyncQueryable source, Ca private static MethodInfo? s_MinAsync__2__5; - private static MethodInfo? MinAsync__2__5 => + private static MethodInfo MinAsync__2__5 => (s_MinAsync__2__5 ?? (s_MinAsync__2__5 = new Func, CancellationToken, ValueTask>(MinAsync).GetMethodInfo())); @@ -2950,7 +2950,7 @@ public static ValueTask MinAsync(this IAsyncQueryable source, Canc private static MethodInfo? s_MinAsync__2__6; - private static MethodInfo? MinAsync__2__6 => + private static MethodInfo MinAsync__2__6 => (s_MinAsync__2__6 ?? (s_MinAsync__2__6 = new Func, CancellationToken, ValueTask>(MinAsync).GetMethodInfo())); @@ -2964,7 +2964,7 @@ public static ValueTask MinAsync(this IAsyncQueryable source, Canc private static MethodInfo? s_MinAsync__2__7; - private static MethodInfo? MinAsync__2__7 => + private static MethodInfo MinAsync__2__7 => (s_MinAsync__2__7 ?? (s_MinAsync__2__7 = new Func, CancellationToken, ValueTask>(MinAsync).GetMethodInfo())); @@ -2978,7 +2978,7 @@ public static ValueTask MinAsync(this IAsyncQueryable source, Cancella private static MethodInfo? s_MinAsync__2__8; - private static MethodInfo? MinAsync__2__8 => + private static MethodInfo MinAsync__2__8 => (s_MinAsync__2__8 ?? (s_MinAsync__2__8 = new Func, CancellationToken, ValueTask>(MinAsync).GetMethodInfo())); @@ -2992,7 +2992,7 @@ public static ValueTask MinAsync(this IAsyncQueryable source, Cancella private static MethodInfo? s_MinAsync__2__9; - private static MethodInfo? MinAsync__2__9 => + private static MethodInfo MinAsync__2__9 => (s_MinAsync__2__9 ?? (s_MinAsync__2__9 = new Func, CancellationToken, ValueTask>(MinAsync).GetMethodInfo())); @@ -3006,7 +3006,7 @@ public static ValueTask MinAsync(this IAsyncQueryable source, Cancel private static MethodInfo? s_MinAsync__TSource__2__0; - private static MethodInfo? MinAsync__TSource__2__0(Type TSource) => + private static MethodInfo MinAsync__TSource__2__0(Type TSource) => (s_MinAsync__TSource__2__0 ?? (s_MinAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3020,7 +3020,7 @@ public static ValueTask MinAsync(this IAsyncQueryable private static MethodInfo? s_MinAsync__TSource__3__0; - private static MethodInfo? MinAsync__TSource__3__0(Type TSource) => + private static MethodInfo MinAsync__TSource__3__0(Type TSource) => (s_MinAsync__TSource__3__0 ?? (s_MinAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3036,7 +3036,7 @@ public static ValueTask MinAsync(this IAsyncQueryable private static MethodInfo? s_MinAsync__TSource__3__1; - private static MethodInfo? MinAsync__TSource__3__1(Type TSource) => + private static MethodInfo MinAsync__TSource__3__1(Type TSource) => (s_MinAsync__TSource__3__1 ?? (s_MinAsync__TSource__3__1 = new Func, Expression>, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3052,7 +3052,7 @@ public static ValueTask MinAsync(this IAsyncQueryable private static MethodInfo? s_MinAsync__TSource__3__2; - private static MethodInfo? MinAsync__TSource__3__2(Type TSource) => + private static MethodInfo MinAsync__TSource__3__2(Type TSource) => (s_MinAsync__TSource__3__2 ?? (s_MinAsync__TSource__3__2 = new Func, Expression>, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3068,7 +3068,7 @@ public static ValueTask MinAsync(this IAsyncQueryable private static MethodInfo? s_MinAsync__TSource__3__3; - private static MethodInfo? MinAsync__TSource__3__3(Type TSource) => + private static MethodInfo MinAsync__TSource__3__3(Type TSource) => (s_MinAsync__TSource__3__3 ?? (s_MinAsync__TSource__3__3 = new Func, Expression>, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3084,7 +3084,7 @@ public static ValueTask MinAsync(this IAsyncQueryable private static MethodInfo? s_MinAsync__TSource__3__4; - private static MethodInfo? MinAsync__TSource__3__4(Type TSource) => + private static MethodInfo MinAsync__TSource__3__4(Type TSource) => (s_MinAsync__TSource__3__4 ?? (s_MinAsync__TSource__3__4 = new Func, Expression>, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3100,7 +3100,7 @@ public static ValueTask MinAsync(this IAsyncQueryable private static MethodInfo? s_MinAsync__TSource__3__5; - private static MethodInfo? MinAsync__TSource__3__5(Type TSource) => + private static MethodInfo MinAsync__TSource__3__5(Type TSource) => (s_MinAsync__TSource__3__5 ?? (s_MinAsync__TSource__3__5 = new Func, Expression>, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3116,7 +3116,7 @@ public static ValueTask MinAsync(this IAsyncQueryable s private static MethodInfo? s_MinAsync__TSource__3__6; - private static MethodInfo? MinAsync__TSource__3__6(Type TSource) => + private static MethodInfo MinAsync__TSource__3__6(Type TSource) => (s_MinAsync__TSource__3__6 ?? (s_MinAsync__TSource__3__6 = new Func, Expression>, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3132,7 +3132,7 @@ public static ValueTask MinAsync(this IAsyncQueryable s private static MethodInfo? s_MinAsync__TSource__3__7; - private static MethodInfo? MinAsync__TSource__3__7(Type TSource) => + private static MethodInfo MinAsync__TSource__3__7(Type TSource) => (s_MinAsync__TSource__3__7 ?? (s_MinAsync__TSource__3__7 = new Func, Expression>, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3148,7 +3148,7 @@ public static ValueTask MinAsync(this IAsyncQueryable sou private static MethodInfo? s_MinAsync__TSource__3__8; - private static MethodInfo? MinAsync__TSource__3__8(Type TSource) => + private static MethodInfo MinAsync__TSource__3__8(Type TSource) => (s_MinAsync__TSource__3__8 ?? (s_MinAsync__TSource__3__8 = new Func, Expression>, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3164,7 +3164,7 @@ public static ValueTask MinAsync(this IAsyncQueryable sou private static MethodInfo? s_MinAsync__TSource__3__9; - private static MethodInfo? MinAsync__TSource__3__9(Type TSource) => + private static MethodInfo MinAsync__TSource__3__9(Type TSource) => (s_MinAsync__TSource__3__9 ?? (s_MinAsync__TSource__3__9 = new Func, Expression>, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3180,7 +3180,7 @@ public static ValueTask MinAsync(this IAsyncQueryable so private static MethodInfo? s_MinAsync__TSource_TResult__3__0; - private static MethodInfo? MinAsync__TSource_TResult__3__0(Type TSource, Type TResult) => + private static MethodInfo MinAsync__TSource_TResult__3__0(Type TSource, Type TResult) => (s_MinAsync__TSource_TResult__3__0 ?? (s_MinAsync__TSource_TResult__3__0 = new Func, Expression>, CancellationToken, ValueTask>(MinAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3196,7 +3196,7 @@ public static ValueTask MinAsync(this IAsyncQueryable private static MethodInfo? s_MinAwaitAsync__TSource__3__0; - private static MethodInfo? MinAwaitAsync__TSource__3__0(Type TSource) => + private static MethodInfo MinAwaitAsync__TSource__3__0(Type TSource) => (s_MinAwaitAsync__TSource__3__0 ?? (s_MinAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3212,7 +3212,7 @@ public static ValueTask MinAsync(this IAsyncQueryable private static MethodInfo? s_MinAwaitAsync__TSource__3__1; - private static MethodInfo? MinAwaitAsync__TSource__3__1(Type TSource) => + private static MethodInfo MinAwaitAsync__TSource__3__1(Type TSource) => (s_MinAwaitAsync__TSource__3__1 ?? (s_MinAwaitAsync__TSource__3__1 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3228,7 +3228,7 @@ public static ValueTask MinAwaitAsync(this IAsyncQueryable + private static MethodInfo MinAwaitAsync__TSource__3__2(Type TSource) => (s_MinAwaitAsync__TSource__3__2 ?? (s_MinAwaitAsync__TSource__3__2 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3244,7 +3244,7 @@ public static ValueTask MinAwaitAsync(this IAsyncQueryable + private static MethodInfo MinAwaitAsync__TSource__3__3(Type TSource) => (s_MinAwaitAsync__TSource__3__3 ?? (s_MinAwaitAsync__TSource__3__3 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3260,7 +3260,7 @@ public static ValueTask MinAwaitAsync(this IAsyncQueryable + private static MethodInfo MinAwaitAsync__TSource__3__4(Type TSource) => (s_MinAwaitAsync__TSource__3__4 ?? (s_MinAwaitAsync__TSource__3__4 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3276,7 +3276,7 @@ public static ValueTask MinAwaitAsync(this IAsyncQueryable + private static MethodInfo MinAwaitAsync__TSource__3__5(Type TSource) => (s_MinAwaitAsync__TSource__3__5 ?? (s_MinAwaitAsync__TSource__3__5 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3292,7 +3292,7 @@ public static ValueTask MinAwaitAsync(this IAsyncQueryable + private static MethodInfo MinAwaitAsync__TSource__3__6(Type TSource) => (s_MinAwaitAsync__TSource__3__6 ?? (s_MinAwaitAsync__TSource__3__6 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3308,7 +3308,7 @@ public static ValueTask MinAwaitAsync(this IAsyncQueryable + private static MethodInfo MinAwaitAsync__TSource__3__7(Type TSource) => (s_MinAwaitAsync__TSource__3__7 ?? (s_MinAwaitAsync__TSource__3__7 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3324,7 +3324,7 @@ public static ValueTask MinAwaitAsync(this IAsyncQueryable + private static MethodInfo MinAwaitAsync__TSource__3__8(Type TSource) => (s_MinAwaitAsync__TSource__3__8 ?? (s_MinAwaitAsync__TSource__3__8 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3340,7 +3340,7 @@ public static ValueTask MinAwaitAsync(this IAsyncQueryable + private static MethodInfo MinAwaitAsync__TSource__3__9(Type TSource) => (s_MinAwaitAsync__TSource__3__9 ?? (s_MinAwaitAsync__TSource__3__9 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3356,7 +3356,7 @@ public static ValueTask MinAwaitAsync(this IAsyncQueryable + private static MethodInfo MinAwaitAsync__TSource_TResult__3__0(Type TSource, Type TResult) => (s_MinAwaitAsync__TSource_TResult__3__0 ?? (s_MinAwaitAsync__TSource_TResult__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3372,7 +3372,7 @@ public static ValueTask MinAwaitAsync(this IAsyncQuer private static MethodInfo? s_MinAwaitWithCancellationAsync__TSource__3__0; - private static MethodInfo? MinAwaitWithCancellationAsync__TSource__3__0(Type TSource) => + private static MethodInfo MinAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_MinAwaitWithCancellationAsync__TSource__3__0 ?? (s_MinAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3388,7 +3388,7 @@ public static ValueTask MinAwaitAsync(this IAsyncQuer private static MethodInfo? s_MinAwaitWithCancellationAsync__TSource__3__1; - private static MethodInfo? MinAwaitWithCancellationAsync__TSource__3__1(Type TSource) => + private static MethodInfo MinAwaitWithCancellationAsync__TSource__3__1(Type TSource) => (s_MinAwaitWithCancellationAsync__TSource__3__1 ?? (s_MinAwaitWithCancellationAsync__TSource__3__1 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3404,7 +3404,7 @@ public static ValueTask MinAwaitWithCancellationAsync(this IAs private static MethodInfo? s_MinAwaitWithCancellationAsync__TSource__3__2; - private static MethodInfo? MinAwaitWithCancellationAsync__TSource__3__2(Type TSource) => + private static MethodInfo MinAwaitWithCancellationAsync__TSource__3__2(Type TSource) => (s_MinAwaitWithCancellationAsync__TSource__3__2 ?? (s_MinAwaitWithCancellationAsync__TSource__3__2 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3420,7 +3420,7 @@ public static ValueTask MinAwaitWithCancellationAsync(this IAs private static MethodInfo? s_MinAwaitWithCancellationAsync__TSource__3__3; - private static MethodInfo? MinAwaitWithCancellationAsync__TSource__3__3(Type TSource) => + private static MethodInfo MinAwaitWithCancellationAsync__TSource__3__3(Type TSource) => (s_MinAwaitWithCancellationAsync__TSource__3__3 ?? (s_MinAwaitWithCancellationAsync__TSource__3__3 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3436,7 +3436,7 @@ public static ValueTask MinAwaitWithCancellationAsync(this IAsy private static MethodInfo? s_MinAwaitWithCancellationAsync__TSource__3__4; - private static MethodInfo? MinAwaitWithCancellationAsync__TSource__3__4(Type TSource) => + private static MethodInfo MinAwaitWithCancellationAsync__TSource__3__4(Type TSource) => (s_MinAwaitWithCancellationAsync__TSource__3__4 ?? (s_MinAwaitWithCancellationAsync__TSource__3__4 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3452,7 +3452,7 @@ public static ValueTask MinAwaitWithCancellationAsync(this IAsy private static MethodInfo? s_MinAwaitWithCancellationAsync__TSource__3__5; - private static MethodInfo? MinAwaitWithCancellationAsync__TSource__3__5(Type TSource) => + private static MethodInfo MinAwaitWithCancellationAsync__TSource__3__5(Type TSource) => (s_MinAwaitWithCancellationAsync__TSource__3__5 ?? (s_MinAwaitWithCancellationAsync__TSource__3__5 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3468,7 +3468,7 @@ public static ValueTask MinAwaitWithCancellationAsync(this IAsyn private static MethodInfo? s_MinAwaitWithCancellationAsync__TSource__3__6; - private static MethodInfo? MinAwaitWithCancellationAsync__TSource__3__6(Type TSource) => + private static MethodInfo MinAwaitWithCancellationAsync__TSource__3__6(Type TSource) => (s_MinAwaitWithCancellationAsync__TSource__3__6 ?? (s_MinAwaitWithCancellationAsync__TSource__3__6 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3484,7 +3484,7 @@ public static ValueTask MinAwaitWithCancellationAsync(this IAsyn private static MethodInfo? s_MinAwaitWithCancellationAsync__TSource__3__7; - private static MethodInfo? MinAwaitWithCancellationAsync__TSource__3__7(Type TSource) => + private static MethodInfo MinAwaitWithCancellationAsync__TSource__3__7(Type TSource) => (s_MinAwaitWithCancellationAsync__TSource__3__7 ?? (s_MinAwaitWithCancellationAsync__TSource__3__7 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3500,7 +3500,7 @@ public static ValueTask MinAwaitWithCancellationAsync(this IAsyncQ private static MethodInfo? s_MinAwaitWithCancellationAsync__TSource__3__8; - private static MethodInfo? MinAwaitWithCancellationAsync__TSource__3__8(Type TSource) => + private static MethodInfo MinAwaitWithCancellationAsync__TSource__3__8(Type TSource) => (s_MinAwaitWithCancellationAsync__TSource__3__8 ?? (s_MinAwaitWithCancellationAsync__TSource__3__8 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3516,7 +3516,7 @@ public static ValueTask MinAwaitWithCancellationAsync(this IAsyncQ private static MethodInfo? s_MinAwaitWithCancellationAsync__TSource__3__9; - private static MethodInfo? MinAwaitWithCancellationAsync__TSource__3__9(Type TSource) => + private static MethodInfo MinAwaitWithCancellationAsync__TSource__3__9(Type TSource) => (s_MinAwaitWithCancellationAsync__TSource__3__9 ?? (s_MinAwaitWithCancellationAsync__TSource__3__9 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3532,7 +3532,7 @@ public static ValueTask MinAwaitWithCancellationAsync(this IAsync private static MethodInfo? s_MinAwaitWithCancellationAsync__TSource_TResult__3__0; - private static MethodInfo? MinAwaitWithCancellationAsync__TSource_TResult__3__0(Type TSource, Type TResult) => + private static MethodInfo MinAwaitWithCancellationAsync__TSource_TResult__3__0(Type TSource, Type TResult) => (s_MinAwaitWithCancellationAsync__TSource_TResult__3__0 ?? (s_MinAwaitWithCancellationAsync__TSource_TResult__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(MinAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3548,11 +3548,11 @@ public static ValueTask MinAwaitWithCancellationAsync private static MethodInfo? s_OfType__TResult__1__0; - private static MethodInfo? OfType__TResult__1__0(Type TResult) => + private static MethodInfo OfType__TResult__1__0(Type TResult) => (s_OfType__TResult__1__0 ?? - (s_OfType__TResult__1__0 = new Func, IAsyncQueryable>(OfType).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TResult); + (s_OfType__TResult__1__0 = new Func, IAsyncQueryable>(OfType).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TResult); - public static IAsyncQueryable OfType(this IAsyncQueryable source) + public static IAsyncQueryable OfType(this IAsyncQueryable source) { if (source == null) throw new ArgumentNullException(nameof(source)); @@ -3562,7 +3562,7 @@ public static IAsyncQueryable OfType(this IAsyncQueryable + private static MethodInfo OrderBy__TSource_TKey__2__0(Type TSource, Type TKey) => (s_OrderBy__TSource_TKey__2__0 ?? (s_OrderBy__TSource_TKey__2__0 = new Func, Expression>, IOrderedAsyncQueryable>(OrderBy).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -3578,7 +3578,7 @@ public static IOrderedAsyncQueryable OrderBy(this IAsync private static MethodInfo? s_OrderBy__TSource_TKey__3__0; - private static MethodInfo? OrderBy__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo OrderBy__TSource_TKey__3__0(Type TSource, Type TKey) => (s_OrderBy__TSource_TKey__3__0 ?? (s_OrderBy__TSource_TKey__3__0 = new Func, Expression>, IComparer, IOrderedAsyncQueryable>(OrderBy).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -3594,7 +3594,7 @@ public static IOrderedAsyncQueryable OrderBy(this IAsync private static MethodInfo? s_OrderByAwait__TSource_TKey__2__0; - private static MethodInfo? OrderByAwait__TSource_TKey__2__0(Type TSource, Type TKey) => + private static MethodInfo OrderByAwait__TSource_TKey__2__0(Type TSource, Type TKey) => (s_OrderByAwait__TSource_TKey__2__0 ?? (s_OrderByAwait__TSource_TKey__2__0 = new Func, Expression>>, IOrderedAsyncQueryable>(OrderByAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -3610,7 +3610,7 @@ public static IOrderedAsyncQueryable OrderByAwait(this I private static MethodInfo? s_OrderByAwait__TSource_TKey__3__0; - private static MethodInfo? OrderByAwait__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo OrderByAwait__TSource_TKey__3__0(Type TSource, Type TKey) => (s_OrderByAwait__TSource_TKey__3__0 ?? (s_OrderByAwait__TSource_TKey__3__0 = new Func, Expression>>, IComparer, IOrderedAsyncQueryable>(OrderByAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -3626,7 +3626,7 @@ public static IOrderedAsyncQueryable OrderByAwait(this I private static MethodInfo? s_OrderByAwaitWithCancellation__TSource_TKey__2__0; - private static MethodInfo? OrderByAwaitWithCancellation__TSource_TKey__2__0(Type TSource, Type TKey) => + private static MethodInfo OrderByAwaitWithCancellation__TSource_TKey__2__0(Type TSource, Type TKey) => (s_OrderByAwaitWithCancellation__TSource_TKey__2__0 ?? (s_OrderByAwaitWithCancellation__TSource_TKey__2__0 = new Func, Expression>>, IOrderedAsyncQueryable>(OrderByAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -3642,7 +3642,7 @@ public static IOrderedAsyncQueryable OrderByAwaitWithCancellation + private static MethodInfo OrderByAwaitWithCancellation__TSource_TKey__3__0(Type TSource, Type TKey) => (s_OrderByAwaitWithCancellation__TSource_TKey__3__0 ?? (s_OrderByAwaitWithCancellation__TSource_TKey__3__0 = new Func, Expression>>, IComparer, IOrderedAsyncQueryable>(OrderByAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -3658,7 +3658,7 @@ public static IOrderedAsyncQueryable OrderByAwaitWithCancellation + private static MethodInfo OrderByDescending__TSource_TKey__2__0(Type TSource, Type TKey) => (s_OrderByDescending__TSource_TKey__2__0 ?? (s_OrderByDescending__TSource_TKey__2__0 = new Func, Expression>, IOrderedAsyncQueryable>(OrderByDescending).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -3674,7 +3674,7 @@ public static IOrderedAsyncQueryable OrderByDescending(t private static MethodInfo? s_OrderByDescending__TSource_TKey__3__0; - private static MethodInfo? OrderByDescending__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo OrderByDescending__TSource_TKey__3__0(Type TSource, Type TKey) => (s_OrderByDescending__TSource_TKey__3__0 ?? (s_OrderByDescending__TSource_TKey__3__0 = new Func, Expression>, IComparer, IOrderedAsyncQueryable>(OrderByDescending).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -3690,7 +3690,7 @@ public static IOrderedAsyncQueryable OrderByDescending(t private static MethodInfo? s_OrderByDescendingAwait__TSource_TKey__2__0; - private static MethodInfo? OrderByDescendingAwait__TSource_TKey__2__0(Type TSource, Type TKey) => + private static MethodInfo OrderByDescendingAwait__TSource_TKey__2__0(Type TSource, Type TKey) => (s_OrderByDescendingAwait__TSource_TKey__2__0 ?? (s_OrderByDescendingAwait__TSource_TKey__2__0 = new Func, Expression>>, IOrderedAsyncQueryable>(OrderByDescendingAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -3706,7 +3706,7 @@ public static IOrderedAsyncQueryable OrderByDescendingAwait + private static MethodInfo OrderByDescendingAwait__TSource_TKey__3__0(Type TSource, Type TKey) => (s_OrderByDescendingAwait__TSource_TKey__3__0 ?? (s_OrderByDescendingAwait__TSource_TKey__3__0 = new Func, Expression>>, IComparer, IOrderedAsyncQueryable>(OrderByDescendingAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -3722,7 +3722,7 @@ public static IOrderedAsyncQueryable OrderByDescendingAwait + private static MethodInfo OrderByDescendingAwaitWithCancellation__TSource_TKey__2__0(Type TSource, Type TKey) => (s_OrderByDescendingAwaitWithCancellation__TSource_TKey__2__0 ?? (s_OrderByDescendingAwaitWithCancellation__TSource_TKey__2__0 = new Func, Expression>>, IOrderedAsyncQueryable>(OrderByDescendingAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -3738,7 +3738,7 @@ public static IOrderedAsyncQueryable OrderByDescendingAwaitWithCancella private static MethodInfo? s_OrderByDescendingAwaitWithCancellation__TSource_TKey__3__0; - private static MethodInfo? OrderByDescendingAwaitWithCancellation__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo OrderByDescendingAwaitWithCancellation__TSource_TKey__3__0(Type TSource, Type TKey) => (s_OrderByDescendingAwaitWithCancellation__TSource_TKey__3__0 ?? (s_OrderByDescendingAwaitWithCancellation__TSource_TKey__3__0 = new Func, Expression>>, IComparer, IOrderedAsyncQueryable>(OrderByDescendingAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -3754,7 +3754,7 @@ public static IOrderedAsyncQueryable OrderByDescendingAwaitWithCancella private static MethodInfo? s_Prepend__TSource__2__0; - private static MethodInfo? Prepend__TSource__2__0(Type TSource) => + private static MethodInfo Prepend__TSource__2__0(Type TSource) => (s_Prepend__TSource__2__0 ?? (s_Prepend__TSource__2__0 = new Func, object, IAsyncQueryable>(Prepend).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3768,7 +3768,7 @@ public static IAsyncQueryable Prepend(this IAsyncQueryable + private static MethodInfo Reverse__TSource__1__0(Type TSource) => (s_Reverse__TSource__1__0 ?? (s_Reverse__TSource__1__0 = new Func, IAsyncQueryable>(Reverse).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -3782,7 +3782,7 @@ public static IAsyncQueryable Reverse(this IAsyncQueryable + private static MethodInfo Select__TSource_TResult__2__0(Type TSource, Type TResult) => (s_Select__TSource_TResult__2__0 ?? (s_Select__TSource_TResult__2__0 = new Func, Expression>, IAsyncQueryable>(Select).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3798,7 +3798,7 @@ public static IAsyncQueryable Select(this IAsyncQuery private static MethodInfo? s_Select__TSource_TResult__2__1; - private static MethodInfo? Select__TSource_TResult__2__1(Type TSource, Type TResult) => + private static MethodInfo Select__TSource_TResult__2__1(Type TSource, Type TResult) => (s_Select__TSource_TResult__2__1 ?? (s_Select__TSource_TResult__2__1 = new Func, Expression>, IAsyncQueryable>(Select).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3814,7 +3814,7 @@ public static IAsyncQueryable Select(this IAsyncQuery private static MethodInfo? s_SelectAwait__TSource_TResult__2__0; - private static MethodInfo? SelectAwait__TSource_TResult__2__0(Type TSource, Type TResult) => + private static MethodInfo SelectAwait__TSource_TResult__2__0(Type TSource, Type TResult) => (s_SelectAwait__TSource_TResult__2__0 ?? (s_SelectAwait__TSource_TResult__2__0 = new Func, Expression>>, IAsyncQueryable>(SelectAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3830,7 +3830,7 @@ public static IAsyncQueryable SelectAwait(this IAsync private static MethodInfo? s_SelectAwait__TSource_TResult__2__1; - private static MethodInfo? SelectAwait__TSource_TResult__2__1(Type TSource, Type TResult) => + private static MethodInfo SelectAwait__TSource_TResult__2__1(Type TSource, Type TResult) => (s_SelectAwait__TSource_TResult__2__1 ?? (s_SelectAwait__TSource_TResult__2__1 = new Func, Expression>>, IAsyncQueryable>(SelectAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3846,7 +3846,7 @@ public static IAsyncQueryable SelectAwait(this IAsync private static MethodInfo? s_SelectAwaitWithCancellation__TSource_TResult__2__0; - private static MethodInfo? SelectAwaitWithCancellation__TSource_TResult__2__0(Type TSource, Type TResult) => + private static MethodInfo SelectAwaitWithCancellation__TSource_TResult__2__0(Type TSource, Type TResult) => (s_SelectAwaitWithCancellation__TSource_TResult__2__0 ?? (s_SelectAwaitWithCancellation__TSource_TResult__2__0 = new Func, Expression>>, IAsyncQueryable>(SelectAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3862,7 +3862,7 @@ public static IAsyncQueryable SelectAwaitWithCancellation + private static MethodInfo SelectAwaitWithCancellation__TSource_TResult__2__1(Type TSource, Type TResult) => (s_SelectAwaitWithCancellation__TSource_TResult__2__1 ?? (s_SelectAwaitWithCancellation__TSource_TResult__2__1 = new Func, Expression>>, IAsyncQueryable>(SelectAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3878,7 +3878,7 @@ public static IAsyncQueryable SelectAwaitWithCancellation + private static MethodInfo SelectMany__TSource_TResult__2__0(Type TSource, Type TResult) => (s_SelectMany__TSource_TResult__2__0 ?? (s_SelectMany__TSource_TResult__2__0 = new Func, Expression>>, IAsyncQueryable>(SelectMany).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3894,7 +3894,7 @@ public static IAsyncQueryable SelectMany(this IAsyncQ private static MethodInfo? s_SelectMany__TSource_TResult__2__1; - private static MethodInfo? SelectMany__TSource_TResult__2__1(Type TSource, Type TResult) => + private static MethodInfo SelectMany__TSource_TResult__2__1(Type TSource, Type TResult) => (s_SelectMany__TSource_TResult__2__1 ?? (s_SelectMany__TSource_TResult__2__1 = new Func, Expression>>, IAsyncQueryable>(SelectMany).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3910,7 +3910,7 @@ public static IAsyncQueryable SelectMany(this IAsyncQ private static MethodInfo? s_SelectMany__TSource_TCollection_TResult__3__0; - private static MethodInfo? SelectMany__TSource_TCollection_TResult__3__0(Type TSource, Type TCollection, Type TResult) => + private static MethodInfo SelectMany__TSource_TCollection_TResult__3__0(Type TSource, Type TCollection, Type TResult) => (s_SelectMany__TSource_TCollection_TResult__3__0 ?? (s_SelectMany__TSource_TCollection_TResult__3__0 = new Func, Expression>>, Expression>, IAsyncQueryable>(SelectMany).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TCollection, TResult); @@ -3928,7 +3928,7 @@ public static IAsyncQueryable SelectMany private static MethodInfo? s_SelectMany__TSource_TCollection_TResult__3__1; - private static MethodInfo? SelectMany__TSource_TCollection_TResult__3__1(Type TSource, Type TCollection, Type TResult) => + private static MethodInfo SelectMany__TSource_TCollection_TResult__3__1(Type TSource, Type TCollection, Type TResult) => (s_SelectMany__TSource_TCollection_TResult__3__1 ?? (s_SelectMany__TSource_TCollection_TResult__3__1 = new Func, Expression>>, Expression>, IAsyncQueryable>(SelectMany).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TCollection, TResult); @@ -3946,7 +3946,7 @@ public static IAsyncQueryable SelectMany private static MethodInfo? s_SelectManyAwait__TSource_TResult__2__0; - private static MethodInfo? SelectManyAwait__TSource_TResult__2__0(Type TSource, Type TResult) => + private static MethodInfo SelectManyAwait__TSource_TResult__2__0(Type TSource, Type TResult) => (s_SelectManyAwait__TSource_TResult__2__0 ?? (s_SelectManyAwait__TSource_TResult__2__0 = new Func, Expression>>>, IAsyncQueryable>(SelectManyAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3962,7 +3962,7 @@ public static IAsyncQueryable SelectManyAwait(this IA private static MethodInfo? s_SelectManyAwait__TSource_TResult__2__1; - private static MethodInfo? SelectManyAwait__TSource_TResult__2__1(Type TSource, Type TResult) => + private static MethodInfo SelectManyAwait__TSource_TResult__2__1(Type TSource, Type TResult) => (s_SelectManyAwait__TSource_TResult__2__1 ?? (s_SelectManyAwait__TSource_TResult__2__1 = new Func, Expression>>>, IAsyncQueryable>(SelectManyAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -3978,7 +3978,7 @@ public static IAsyncQueryable SelectManyAwait(this IA private static MethodInfo? s_SelectManyAwait__TSource_TCollection_TResult__3__0; - private static MethodInfo? SelectManyAwait__TSource_TCollection_TResult__3__0(Type TSource, Type TCollection, Type TResult) => + private static MethodInfo SelectManyAwait__TSource_TCollection_TResult__3__0(Type TSource, Type TCollection, Type TResult) => (s_SelectManyAwait__TSource_TCollection_TResult__3__0 ?? (s_SelectManyAwait__TSource_TCollection_TResult__3__0 = new Func, Expression>>>, Expression>>, IAsyncQueryable>(SelectManyAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TCollection, TResult); @@ -3996,7 +3996,7 @@ public static IAsyncQueryable SelectManyAwait + private static MethodInfo SelectManyAwait__TSource_TCollection_TResult__3__1(Type TSource, Type TCollection, Type TResult) => (s_SelectManyAwait__TSource_TCollection_TResult__3__1 ?? (s_SelectManyAwait__TSource_TCollection_TResult__3__1 = new Func, Expression>>>, Expression>>, IAsyncQueryable>(SelectManyAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TCollection, TResult); @@ -4014,7 +4014,7 @@ public static IAsyncQueryable SelectManyAwait + private static MethodInfo SelectManyAwaitWithCancellation__TSource_TResult__2__0(Type TSource, Type TResult) => (s_SelectManyAwaitWithCancellation__TSource_TResult__2__0 ?? (s_SelectManyAwaitWithCancellation__TSource_TResult__2__0 = new Func, Expression>>>, IAsyncQueryable>(SelectManyAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -4030,7 +4030,7 @@ public static IAsyncQueryable SelectManyAwaitWithCancellation + private static MethodInfo SelectManyAwaitWithCancellation__TSource_TResult__2__1(Type TSource, Type TResult) => (s_SelectManyAwaitWithCancellation__TSource_TResult__2__1 ?? (s_SelectManyAwaitWithCancellation__TSource_TResult__2__1 = new Func, Expression>>>, IAsyncQueryable>(SelectManyAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TResult); @@ -4046,7 +4046,7 @@ public static IAsyncQueryable SelectManyAwaitWithCancellation + private static MethodInfo SelectManyAwaitWithCancellation__TSource_TCollection_TResult__3__0(Type TSource, Type TCollection, Type TResult) => (s_SelectManyAwaitWithCancellation__TSource_TCollection_TResult__3__0 ?? (s_SelectManyAwaitWithCancellation__TSource_TCollection_TResult__3__0 = new Func, Expression>>>, Expression>>, IAsyncQueryable>(SelectManyAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TCollection, TResult); @@ -4064,7 +4064,7 @@ public static IAsyncQueryable SelectManyAwaitWithCancellation + private static MethodInfo SelectManyAwaitWithCancellation__TSource_TCollection_TResult__3__1(Type TSource, Type TCollection, Type TResult) => (s_SelectManyAwaitWithCancellation__TSource_TCollection_TResult__3__1 ?? (s_SelectManyAwaitWithCancellation__TSource_TCollection_TResult__3__1 = new Func, Expression>>>, Expression>>, IAsyncQueryable>(SelectManyAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TCollection, TResult); @@ -4082,7 +4082,7 @@ public static IAsyncQueryable SelectManyAwaitWithCancellation + private static MethodInfo SequenceEqualAsync__TSource__3__0(Type TSource) => (s_SequenceEqualAsync__TSource__3__0 ?? (s_SequenceEqualAsync__TSource__3__0 = new Func, IAsyncEnumerable, CancellationToken, ValueTask>(SequenceEqualAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4098,7 +4098,7 @@ public static ValueTask SequenceEqualAsync(this IAsyncQueryable + private static MethodInfo SequenceEqualAsync__TSource__4__0(Type TSource) => (s_SequenceEqualAsync__TSource__4__0 ?? (s_SequenceEqualAsync__TSource__4__0 = new Func, IAsyncEnumerable, IEqualityComparer, CancellationToken, ValueTask>(SequenceEqualAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4114,7 +4114,7 @@ public static ValueTask SequenceEqualAsync(this IAsyncQueryable + private static MethodInfo SingleAsync__TSource__2__0(Type TSource) => (s_SingleAsync__TSource__2__0 ?? (s_SingleAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(SingleAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4128,7 +4128,7 @@ public static ValueTask SingleAsync(this IAsyncQueryable + private static MethodInfo SingleAsync__TSource__3__0(Type TSource) => (s_SingleAsync__TSource__3__0 ?? (s_SingleAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(SingleAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4144,7 +4144,7 @@ public static ValueTask SingleAsync(this IAsyncQueryable + private static MethodInfo SingleAwaitAsync__TSource__3__0(Type TSource) => (s_SingleAwaitAsync__TSource__3__0 ?? (s_SingleAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(SingleAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4160,7 +4160,7 @@ public static ValueTask SingleAwaitAsync(this IAsyncQueryable< private static MethodInfo? s_SingleAwaitWithCancellationAsync__TSource__3__0; - private static MethodInfo? SingleAwaitWithCancellationAsync__TSource__3__0(Type TSource) => + private static MethodInfo SingleAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_SingleAwaitWithCancellationAsync__TSource__3__0 ?? (s_SingleAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(SingleAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4176,7 +4176,7 @@ public static ValueTask SingleAwaitWithCancellationAsync(this private static MethodInfo? s_SingleOrDefaultAsync__TSource__2__0; - private static MethodInfo? SingleOrDefaultAsync__TSource__2__0(Type TSource) => + private static MethodInfo SingleOrDefaultAsync__TSource__2__0(Type TSource) => (s_SingleOrDefaultAsync__TSource__2__0 ?? (s_SingleOrDefaultAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(SingleOrDefaultAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4190,7 +4190,7 @@ public static ValueTask SingleAwaitWithCancellationAsync(this private static MethodInfo? s_SingleOrDefaultAsync__TSource__3__0; - private static MethodInfo? SingleOrDefaultAsync__TSource__3__0(Type TSource) => + private static MethodInfo SingleOrDefaultAsync__TSource__3__0(Type TSource) => (s_SingleOrDefaultAsync__TSource__3__0 ?? (s_SingleOrDefaultAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(SingleOrDefaultAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4206,7 +4206,7 @@ public static ValueTask SingleAwaitWithCancellationAsync(this private static MethodInfo? s_SingleOrDefaultAwaitAsync__TSource__3__0; - private static MethodInfo? SingleOrDefaultAwaitAsync__TSource__3__0(Type TSource) => + private static MethodInfo SingleOrDefaultAwaitAsync__TSource__3__0(Type TSource) => (s_SingleOrDefaultAwaitAsync__TSource__3__0 ?? (s_SingleOrDefaultAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(SingleOrDefaultAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4222,7 +4222,7 @@ public static ValueTask SingleAwaitWithCancellationAsync(this private static MethodInfo? s_SingleOrDefaultAwaitWithCancellationAsync__TSource__3__0; - private static MethodInfo? SingleOrDefaultAwaitWithCancellationAsync__TSource__3__0(Type TSource) => + private static MethodInfo SingleOrDefaultAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_SingleOrDefaultAwaitWithCancellationAsync__TSource__3__0 ?? (s_SingleOrDefaultAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(SingleOrDefaultAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4238,7 +4238,7 @@ public static ValueTask SingleAwaitWithCancellationAsync(this private static MethodInfo? s_Skip__TSource__2__0; - private static MethodInfo? Skip__TSource__2__0(Type TSource) => + private static MethodInfo Skip__TSource__2__0(Type TSource) => (s_Skip__TSource__2__0 ?? (s_Skip__TSource__2__0 = new Func, int, IAsyncQueryable>(Skip).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4252,7 +4252,7 @@ public static IAsyncQueryable Skip(this IAsyncQueryable + private static MethodInfo SkipLast__TSource__2__0(Type TSource) => (s_SkipLast__TSource__2__0 ?? (s_SkipLast__TSource__2__0 = new Func, int, IAsyncQueryable>(SkipLast).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4266,7 +4266,7 @@ public static IAsyncQueryable SkipLast(this IAsyncQueryable + private static MethodInfo SkipWhile__TSource__2__0(Type TSource) => (s_SkipWhile__TSource__2__0 ?? (s_SkipWhile__TSource__2__0 = new Func, Expression>, IAsyncQueryable>(SkipWhile).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4282,7 +4282,7 @@ public static IAsyncQueryable SkipWhile(this IAsyncQueryable + private static MethodInfo SkipWhile__TSource__2__1(Type TSource) => (s_SkipWhile__TSource__2__1 ?? (s_SkipWhile__TSource__2__1 = new Func, Expression>, IAsyncQueryable>(SkipWhile).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4298,7 +4298,7 @@ public static IAsyncQueryable SkipWhile(this IAsyncQueryable + private static MethodInfo SkipWhileAwait__TSource__2__0(Type TSource) => (s_SkipWhileAwait__TSource__2__0 ?? (s_SkipWhileAwait__TSource__2__0 = new Func, Expression>>, IAsyncQueryable>(SkipWhileAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4314,7 +4314,7 @@ public static IAsyncQueryable SkipWhileAwait(this IAsyncQuerya private static MethodInfo? s_SkipWhileAwait__TSource__2__1; - private static MethodInfo? SkipWhileAwait__TSource__2__1(Type TSource) => + private static MethodInfo SkipWhileAwait__TSource__2__1(Type TSource) => (s_SkipWhileAwait__TSource__2__1 ?? (s_SkipWhileAwait__TSource__2__1 = new Func, Expression>>, IAsyncQueryable>(SkipWhileAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4330,7 +4330,7 @@ public static IAsyncQueryable SkipWhileAwait(this IAsyncQuerya private static MethodInfo? s_SkipWhileAwaitWithCancellation__TSource__2__0; - private static MethodInfo? SkipWhileAwaitWithCancellation__TSource__2__0(Type TSource) => + private static MethodInfo SkipWhileAwaitWithCancellation__TSource__2__0(Type TSource) => (s_SkipWhileAwaitWithCancellation__TSource__2__0 ?? (s_SkipWhileAwaitWithCancellation__TSource__2__0 = new Func, Expression>>, IAsyncQueryable>(SkipWhileAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4346,7 +4346,7 @@ public static IAsyncQueryable SkipWhileAwaitWithCancellation(t private static MethodInfo? s_SkipWhileAwaitWithCancellation__TSource__2__1; - private static MethodInfo? SkipWhileAwaitWithCancellation__TSource__2__1(Type TSource) => + private static MethodInfo SkipWhileAwaitWithCancellation__TSource__2__1(Type TSource) => (s_SkipWhileAwaitWithCancellation__TSource__2__1 ?? (s_SkipWhileAwaitWithCancellation__TSource__2__1 = new Func, Expression>>, IAsyncQueryable>(SkipWhileAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4362,7 +4362,7 @@ public static IAsyncQueryable SkipWhileAwaitWithCancellation(t private static MethodInfo? s_SumAsync__2__0; - private static MethodInfo? SumAsync__2__0 => + private static MethodInfo SumAsync__2__0 => (s_SumAsync__2__0 ?? (s_SumAsync__2__0 = new Func, CancellationToken, ValueTask>(SumAsync).GetMethodInfo())); @@ -4376,7 +4376,7 @@ public static IAsyncQueryable SkipWhileAwaitWithCancellation(t private static MethodInfo? s_SumAsync__2__1; - private static MethodInfo? SumAsync__2__1 => + private static MethodInfo SumAsync__2__1 => (s_SumAsync__2__1 ?? (s_SumAsync__2__1 = new Func, CancellationToken, ValueTask>(SumAsync).GetMethodInfo())); @@ -4390,7 +4390,7 @@ public static ValueTask SumAsync(this IAsyncQueryable source, private static MethodInfo? s_SumAsync__2__2; - private static MethodInfo? SumAsync__2__2 => + private static MethodInfo SumAsync__2__2 => (s_SumAsync__2__2 ?? (s_SumAsync__2__2 = new Func, CancellationToken, ValueTask>(SumAsync).GetMethodInfo())); @@ -4404,7 +4404,7 @@ public static ValueTask SumAsync(this IAsyncQueryable source, private static MethodInfo? s_SumAsync__2__3; - private static MethodInfo? SumAsync__2__3 => + private static MethodInfo SumAsync__2__3 => (s_SumAsync__2__3 ?? (s_SumAsync__2__3 = new Func, CancellationToken, ValueTask>(SumAsync).GetMethodInfo())); @@ -4418,7 +4418,7 @@ public static ValueTask SumAsync(this IAsyncQueryable source, Ca private static MethodInfo? s_SumAsync__2__4; - private static MethodInfo? SumAsync__2__4 => + private static MethodInfo SumAsync__2__4 => (s_SumAsync__2__4 ?? (s_SumAsync__2__4 = new Func, CancellationToken, ValueTask>(SumAsync).GetMethodInfo())); @@ -4432,7 +4432,7 @@ public static ValueTask SumAsync(this IAsyncQueryable source, Ca private static MethodInfo? s_SumAsync__2__5; - private static MethodInfo? SumAsync__2__5 => + private static MethodInfo SumAsync__2__5 => (s_SumAsync__2__5 ?? (s_SumAsync__2__5 = new Func, CancellationToken, ValueTask>(SumAsync).GetMethodInfo())); @@ -4446,7 +4446,7 @@ public static ValueTask SumAsync(this IAsyncQueryable source, Canc private static MethodInfo? s_SumAsync__2__6; - private static MethodInfo? SumAsync__2__6 => + private static MethodInfo SumAsync__2__6 => (s_SumAsync__2__6 ?? (s_SumAsync__2__6 = new Func, CancellationToken, ValueTask>(SumAsync).GetMethodInfo())); @@ -4460,7 +4460,7 @@ public static ValueTask SumAsync(this IAsyncQueryable source, Canc private static MethodInfo? s_SumAsync__2__7; - private static MethodInfo? SumAsync__2__7 => + private static MethodInfo SumAsync__2__7 => (s_SumAsync__2__7 ?? (s_SumAsync__2__7 = new Func, CancellationToken, ValueTask>(SumAsync).GetMethodInfo())); @@ -4474,7 +4474,7 @@ public static ValueTask SumAsync(this IAsyncQueryable source, Cancella private static MethodInfo? s_SumAsync__2__8; - private static MethodInfo? SumAsync__2__8 => + private static MethodInfo SumAsync__2__8 => (s_SumAsync__2__8 ?? (s_SumAsync__2__8 = new Func, CancellationToken, ValueTask>(SumAsync).GetMethodInfo())); @@ -4488,7 +4488,7 @@ public static ValueTask SumAsync(this IAsyncQueryable source, Cancella private static MethodInfo? s_SumAsync__2__9; - private static MethodInfo? SumAsync__2__9 => + private static MethodInfo SumAsync__2__9 => (s_SumAsync__2__9 ?? (s_SumAsync__2__9 = new Func, CancellationToken, ValueTask>(SumAsync).GetMethodInfo())); @@ -4502,7 +4502,7 @@ public static ValueTask SumAsync(this IAsyncQueryable source, Cancel private static MethodInfo? s_SumAsync__TSource__3__0; - private static MethodInfo? SumAsync__TSource__3__0(Type TSource) => + private static MethodInfo SumAsync__TSource__3__0(Type TSource) => (s_SumAsync__TSource__3__0 ?? (s_SumAsync__TSource__3__0 = new Func, Expression>, CancellationToken, ValueTask>(SumAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4518,7 +4518,7 @@ public static ValueTask SumAsync(this IAsyncQueryable source, Cancel private static MethodInfo? s_SumAsync__TSource__3__1; - private static MethodInfo? SumAsync__TSource__3__1(Type TSource) => + private static MethodInfo SumAsync__TSource__3__1(Type TSource) => (s_SumAsync__TSource__3__1 ?? (s_SumAsync__TSource__3__1 = new Func, Expression>, CancellationToken, ValueTask>(SumAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4534,7 +4534,7 @@ public static ValueTask SumAsync(this IAsyncQueryable private static MethodInfo? s_SumAsync__TSource__3__2; - private static MethodInfo? SumAsync__TSource__3__2(Type TSource) => + private static MethodInfo SumAsync__TSource__3__2(Type TSource) => (s_SumAsync__TSource__3__2 ?? (s_SumAsync__TSource__3__2 = new Func, Expression>, CancellationToken, ValueTask>(SumAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4550,7 +4550,7 @@ public static ValueTask SumAsync(this IAsyncQueryable private static MethodInfo? s_SumAsync__TSource__3__3; - private static MethodInfo? SumAsync__TSource__3__3(Type TSource) => + private static MethodInfo SumAsync__TSource__3__3(Type TSource) => (s_SumAsync__TSource__3__3 ?? (s_SumAsync__TSource__3__3 = new Func, Expression>, CancellationToken, ValueTask>(SumAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4566,7 +4566,7 @@ public static ValueTask SumAsync(this IAsyncQueryable private static MethodInfo? s_SumAsync__TSource__3__4; - private static MethodInfo? SumAsync__TSource__3__4(Type TSource) => + private static MethodInfo SumAsync__TSource__3__4(Type TSource) => (s_SumAsync__TSource__3__4 ?? (s_SumAsync__TSource__3__4 = new Func, Expression>, CancellationToken, ValueTask>(SumAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4582,7 +4582,7 @@ public static ValueTask SumAsync(this IAsyncQueryable private static MethodInfo? s_SumAsync__TSource__3__5; - private static MethodInfo? SumAsync__TSource__3__5(Type TSource) => + private static MethodInfo SumAsync__TSource__3__5(Type TSource) => (s_SumAsync__TSource__3__5 ?? (s_SumAsync__TSource__3__5 = new Func, Expression>, CancellationToken, ValueTask>(SumAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4598,7 +4598,7 @@ public static ValueTask SumAsync(this IAsyncQueryable s private static MethodInfo? s_SumAsync__TSource__3__6; - private static MethodInfo? SumAsync__TSource__3__6(Type TSource) => + private static MethodInfo SumAsync__TSource__3__6(Type TSource) => (s_SumAsync__TSource__3__6 ?? (s_SumAsync__TSource__3__6 = new Func, Expression>, CancellationToken, ValueTask>(SumAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4614,7 +4614,7 @@ public static ValueTask SumAsync(this IAsyncQueryable s private static MethodInfo? s_SumAsync__TSource__3__7; - private static MethodInfo? SumAsync__TSource__3__7(Type TSource) => + private static MethodInfo SumAsync__TSource__3__7(Type TSource) => (s_SumAsync__TSource__3__7 ?? (s_SumAsync__TSource__3__7 = new Func, Expression>, CancellationToken, ValueTask>(SumAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4630,7 +4630,7 @@ public static ValueTask SumAsync(this IAsyncQueryable sou private static MethodInfo? s_SumAsync__TSource__3__8; - private static MethodInfo? SumAsync__TSource__3__8(Type TSource) => + private static MethodInfo SumAsync__TSource__3__8(Type TSource) => (s_SumAsync__TSource__3__8 ?? (s_SumAsync__TSource__3__8 = new Func, Expression>, CancellationToken, ValueTask>(SumAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4646,7 +4646,7 @@ public static ValueTask SumAsync(this IAsyncQueryable sou private static MethodInfo? s_SumAsync__TSource__3__9; - private static MethodInfo? SumAsync__TSource__3__9(Type TSource) => + private static MethodInfo SumAsync__TSource__3__9(Type TSource) => (s_SumAsync__TSource__3__9 ?? (s_SumAsync__TSource__3__9 = new Func, Expression>, CancellationToken, ValueTask>(SumAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4662,7 +4662,7 @@ public static ValueTask SumAsync(this IAsyncQueryable so private static MethodInfo? s_SumAwaitAsync__TSource__3__0; - private static MethodInfo? SumAwaitAsync__TSource__3__0(Type TSource) => + private static MethodInfo SumAwaitAsync__TSource__3__0(Type TSource) => (s_SumAwaitAsync__TSource__3__0 ?? (s_SumAwaitAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4678,7 +4678,7 @@ public static ValueTask SumAsync(this IAsyncQueryable so private static MethodInfo? s_SumAwaitAsync__TSource__3__1; - private static MethodInfo? SumAwaitAsync__TSource__3__1(Type TSource) => + private static MethodInfo SumAwaitAsync__TSource__3__1(Type TSource) => (s_SumAwaitAsync__TSource__3__1 ?? (s_SumAwaitAsync__TSource__3__1 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4694,7 +4694,7 @@ public static ValueTask SumAwaitAsync(this IAsyncQueryable + private static MethodInfo SumAwaitAsync__TSource__3__2(Type TSource) => (s_SumAwaitAsync__TSource__3__2 ?? (s_SumAwaitAsync__TSource__3__2 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4710,7 +4710,7 @@ public static ValueTask SumAwaitAsync(this IAsyncQueryable + private static MethodInfo SumAwaitAsync__TSource__3__3(Type TSource) => (s_SumAwaitAsync__TSource__3__3 ?? (s_SumAwaitAsync__TSource__3__3 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4726,7 +4726,7 @@ public static ValueTask SumAwaitAsync(this IAsyncQueryable + private static MethodInfo SumAwaitAsync__TSource__3__4(Type TSource) => (s_SumAwaitAsync__TSource__3__4 ?? (s_SumAwaitAsync__TSource__3__4 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4742,7 +4742,7 @@ public static ValueTask SumAwaitAsync(this IAsyncQueryable + private static MethodInfo SumAwaitAsync__TSource__3__5(Type TSource) => (s_SumAwaitAsync__TSource__3__5 ?? (s_SumAwaitAsync__TSource__3__5 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4758,7 +4758,7 @@ public static ValueTask SumAwaitAsync(this IAsyncQueryable + private static MethodInfo SumAwaitAsync__TSource__3__6(Type TSource) => (s_SumAwaitAsync__TSource__3__6 ?? (s_SumAwaitAsync__TSource__3__6 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4774,7 +4774,7 @@ public static ValueTask SumAwaitAsync(this IAsyncQueryable + private static MethodInfo SumAwaitAsync__TSource__3__7(Type TSource) => (s_SumAwaitAsync__TSource__3__7 ?? (s_SumAwaitAsync__TSource__3__7 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4790,7 +4790,7 @@ public static ValueTask SumAwaitAsync(this IAsyncQueryable + private static MethodInfo SumAwaitAsync__TSource__3__8(Type TSource) => (s_SumAwaitAsync__TSource__3__8 ?? (s_SumAwaitAsync__TSource__3__8 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4806,7 +4806,7 @@ public static ValueTask SumAwaitAsync(this IAsyncQueryable + private static MethodInfo SumAwaitAsync__TSource__3__9(Type TSource) => (s_SumAwaitAsync__TSource__3__9 ?? (s_SumAwaitAsync__TSource__3__9 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4822,7 +4822,7 @@ public static ValueTask SumAwaitAsync(this IAsyncQueryable + private static MethodInfo SumAwaitWithCancellationAsync__TSource__3__0(Type TSource) => (s_SumAwaitWithCancellationAsync__TSource__3__0 ?? (s_SumAwaitWithCancellationAsync__TSource__3__0 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4838,7 +4838,7 @@ public static ValueTask SumAwaitAsync(this IAsyncQueryable + private static MethodInfo SumAwaitWithCancellationAsync__TSource__3__1(Type TSource) => (s_SumAwaitWithCancellationAsync__TSource__3__1 ?? (s_SumAwaitWithCancellationAsync__TSource__3__1 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4854,7 +4854,7 @@ public static ValueTask SumAwaitWithCancellationAsync(this IAs private static MethodInfo? s_SumAwaitWithCancellationAsync__TSource__3__2; - private static MethodInfo? SumAwaitWithCancellationAsync__TSource__3__2(Type TSource) => + private static MethodInfo SumAwaitWithCancellationAsync__TSource__3__2(Type TSource) => (s_SumAwaitWithCancellationAsync__TSource__3__2 ?? (s_SumAwaitWithCancellationAsync__TSource__3__2 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4870,7 +4870,7 @@ public static ValueTask SumAwaitWithCancellationAsync(this IAs private static MethodInfo? s_SumAwaitWithCancellationAsync__TSource__3__3; - private static MethodInfo? SumAwaitWithCancellationAsync__TSource__3__3(Type TSource) => + private static MethodInfo SumAwaitWithCancellationAsync__TSource__3__3(Type TSource) => (s_SumAwaitWithCancellationAsync__TSource__3__3 ?? (s_SumAwaitWithCancellationAsync__TSource__3__3 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4886,7 +4886,7 @@ public static ValueTask SumAwaitWithCancellationAsync(this IAsy private static MethodInfo? s_SumAwaitWithCancellationAsync__TSource__3__4; - private static MethodInfo? SumAwaitWithCancellationAsync__TSource__3__4(Type TSource) => + private static MethodInfo SumAwaitWithCancellationAsync__TSource__3__4(Type TSource) => (s_SumAwaitWithCancellationAsync__TSource__3__4 ?? (s_SumAwaitWithCancellationAsync__TSource__3__4 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4902,7 +4902,7 @@ public static ValueTask SumAwaitWithCancellationAsync(this IAsy private static MethodInfo? s_SumAwaitWithCancellationAsync__TSource__3__5; - private static MethodInfo? SumAwaitWithCancellationAsync__TSource__3__5(Type TSource) => + private static MethodInfo SumAwaitWithCancellationAsync__TSource__3__5(Type TSource) => (s_SumAwaitWithCancellationAsync__TSource__3__5 ?? (s_SumAwaitWithCancellationAsync__TSource__3__5 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4918,7 +4918,7 @@ public static ValueTask SumAwaitWithCancellationAsync(this IAsyn private static MethodInfo? s_SumAwaitWithCancellationAsync__TSource__3__6; - private static MethodInfo? SumAwaitWithCancellationAsync__TSource__3__6(Type TSource) => + private static MethodInfo SumAwaitWithCancellationAsync__TSource__3__6(Type TSource) => (s_SumAwaitWithCancellationAsync__TSource__3__6 ?? (s_SumAwaitWithCancellationAsync__TSource__3__6 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4934,7 +4934,7 @@ public static ValueTask SumAwaitWithCancellationAsync(this IAsyn private static MethodInfo? s_SumAwaitWithCancellationAsync__TSource__3__7; - private static MethodInfo? SumAwaitWithCancellationAsync__TSource__3__7(Type TSource) => + private static MethodInfo SumAwaitWithCancellationAsync__TSource__3__7(Type TSource) => (s_SumAwaitWithCancellationAsync__TSource__3__7 ?? (s_SumAwaitWithCancellationAsync__TSource__3__7 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4950,7 +4950,7 @@ public static ValueTask SumAwaitWithCancellationAsync(this IAsyncQ private static MethodInfo? s_SumAwaitWithCancellationAsync__TSource__3__8; - private static MethodInfo? SumAwaitWithCancellationAsync__TSource__3__8(Type TSource) => + private static MethodInfo SumAwaitWithCancellationAsync__TSource__3__8(Type TSource) => (s_SumAwaitWithCancellationAsync__TSource__3__8 ?? (s_SumAwaitWithCancellationAsync__TSource__3__8 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4966,7 +4966,7 @@ public static ValueTask SumAwaitWithCancellationAsync(this IAsyncQ private static MethodInfo? s_SumAwaitWithCancellationAsync__TSource__3__9; - private static MethodInfo? SumAwaitWithCancellationAsync__TSource__3__9(Type TSource) => + private static MethodInfo SumAwaitWithCancellationAsync__TSource__3__9(Type TSource) => (s_SumAwaitWithCancellationAsync__TSource__3__9 ?? (s_SumAwaitWithCancellationAsync__TSource__3__9 = new Func, Expression>>, CancellationToken, ValueTask>(SumAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4982,7 +4982,7 @@ public static ValueTask SumAwaitWithCancellationAsync(this IAsync private static MethodInfo? s_Take__TSource__2__0; - private static MethodInfo? Take__TSource__2__0(Type TSource) => + private static MethodInfo Take__TSource__2__0(Type TSource) => (s_Take__TSource__2__0 ?? (s_Take__TSource__2__0 = new Func, int, IAsyncQueryable>(Take).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -4996,7 +4996,7 @@ public static IAsyncQueryable Take(this IAsyncQueryable + private static MethodInfo TakeLast__TSource__2__0(Type TSource) => (s_TakeLast__TSource__2__0 ?? (s_TakeLast__TSource__2__0 = new Func, int, IAsyncQueryable>(TakeLast).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5010,7 +5010,7 @@ public static IAsyncQueryable TakeLast(this IAsyncQueryable + private static MethodInfo TakeWhile__TSource__2__0(Type TSource) => (s_TakeWhile__TSource__2__0 ?? (s_TakeWhile__TSource__2__0 = new Func, Expression>, IAsyncQueryable>(TakeWhile).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5026,7 +5026,7 @@ public static IAsyncQueryable TakeWhile(this IAsyncQueryable + private static MethodInfo TakeWhile__TSource__2__1(Type TSource) => (s_TakeWhile__TSource__2__1 ?? (s_TakeWhile__TSource__2__1 = new Func, Expression>, IAsyncQueryable>(TakeWhile).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5042,7 +5042,7 @@ public static IAsyncQueryable TakeWhile(this IAsyncQueryable + private static MethodInfo TakeWhileAwait__TSource__2__0(Type TSource) => (s_TakeWhileAwait__TSource__2__0 ?? (s_TakeWhileAwait__TSource__2__0 = new Func, Expression>>, IAsyncQueryable>(TakeWhileAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5058,7 +5058,7 @@ public static IAsyncQueryable TakeWhileAwait(this IAsyncQuerya private static MethodInfo? s_TakeWhileAwait__TSource__2__1; - private static MethodInfo? TakeWhileAwait__TSource__2__1(Type TSource) => + private static MethodInfo TakeWhileAwait__TSource__2__1(Type TSource) => (s_TakeWhileAwait__TSource__2__1 ?? (s_TakeWhileAwait__TSource__2__1 = new Func, Expression>>, IAsyncQueryable>(TakeWhileAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5074,7 +5074,7 @@ public static IAsyncQueryable TakeWhileAwait(this IAsyncQuerya private static MethodInfo? s_TakeWhileAwaitWithCancellation__TSource__2__0; - private static MethodInfo? TakeWhileAwaitWithCancellation__TSource__2__0(Type TSource) => + private static MethodInfo TakeWhileAwaitWithCancellation__TSource__2__0(Type TSource) => (s_TakeWhileAwaitWithCancellation__TSource__2__0 ?? (s_TakeWhileAwaitWithCancellation__TSource__2__0 = new Func, Expression>>, IAsyncQueryable>(TakeWhileAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5090,7 +5090,7 @@ public static IAsyncQueryable TakeWhileAwaitWithCancellation(t private static MethodInfo? s_TakeWhileAwaitWithCancellation__TSource__2__1; - private static MethodInfo? TakeWhileAwaitWithCancellation__TSource__2__1(Type TSource) => + private static MethodInfo TakeWhileAwaitWithCancellation__TSource__2__1(Type TSource) => (s_TakeWhileAwaitWithCancellation__TSource__2__1 ?? (s_TakeWhileAwaitWithCancellation__TSource__2__1 = new Func, Expression>>, IAsyncQueryable>(TakeWhileAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5106,7 +5106,7 @@ public static IAsyncQueryable TakeWhileAwaitWithCancellation(t private static MethodInfo? s_ThenBy__TSource_TKey__2__0; - private static MethodInfo? ThenBy__TSource_TKey__2__0(Type TSource, Type TKey) => + private static MethodInfo ThenBy__TSource_TKey__2__0(Type TSource, Type TKey) => (s_ThenBy__TSource_TKey__2__0 ?? (s_ThenBy__TSource_TKey__2__0 = new Func, Expression>, IOrderedAsyncQueryable>(ThenBy).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5122,7 +5122,7 @@ public static IOrderedAsyncQueryable ThenBy(this IOrdere private static MethodInfo? s_ThenBy__TSource_TKey__3__0; - private static MethodInfo? ThenBy__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo ThenBy__TSource_TKey__3__0(Type TSource, Type TKey) => (s_ThenBy__TSource_TKey__3__0 ?? (s_ThenBy__TSource_TKey__3__0 = new Func, Expression>, IComparer, IOrderedAsyncQueryable>(ThenBy).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5138,7 +5138,7 @@ public static IOrderedAsyncQueryable ThenBy(this IOrdere private static MethodInfo? s_ThenByAwait__TSource_TKey__2__0; - private static MethodInfo? ThenByAwait__TSource_TKey__2__0(Type TSource, Type TKey) => + private static MethodInfo ThenByAwait__TSource_TKey__2__0(Type TSource, Type TKey) => (s_ThenByAwait__TSource_TKey__2__0 ?? (s_ThenByAwait__TSource_TKey__2__0 = new Func, Expression>>, IOrderedAsyncQueryable>(ThenByAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5154,7 +5154,7 @@ public static IOrderedAsyncQueryable ThenByAwait(this IO private static MethodInfo? s_ThenByAwait__TSource_TKey__3__0; - private static MethodInfo? ThenByAwait__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo ThenByAwait__TSource_TKey__3__0(Type TSource, Type TKey) => (s_ThenByAwait__TSource_TKey__3__0 ?? (s_ThenByAwait__TSource_TKey__3__0 = new Func, Expression>>, IComparer, IOrderedAsyncQueryable>(ThenByAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5170,7 +5170,7 @@ public static IOrderedAsyncQueryable ThenByAwait(this IO private static MethodInfo? s_ThenByAwaitWithCancellation__TSource_TKey__2__0; - private static MethodInfo? ThenByAwaitWithCancellation__TSource_TKey__2__0(Type TSource, Type TKey) => + private static MethodInfo ThenByAwaitWithCancellation__TSource_TKey__2__0(Type TSource, Type TKey) => (s_ThenByAwaitWithCancellation__TSource_TKey__2__0 ?? (s_ThenByAwaitWithCancellation__TSource_TKey__2__0 = new Func, Expression>>, IOrderedAsyncQueryable>(ThenByAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5186,7 +5186,7 @@ public static IOrderedAsyncQueryable ThenByAwaitWithCancellation + private static MethodInfo ThenByAwaitWithCancellation__TSource_TKey__3__0(Type TSource, Type TKey) => (s_ThenByAwaitWithCancellation__TSource_TKey__3__0 ?? (s_ThenByAwaitWithCancellation__TSource_TKey__3__0 = new Func, Expression>>, IComparer, IOrderedAsyncQueryable>(ThenByAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5202,7 +5202,7 @@ public static IOrderedAsyncQueryable ThenByAwaitWithCancellation + private static MethodInfo ThenByDescending__TSource_TKey__2__0(Type TSource, Type TKey) => (s_ThenByDescending__TSource_TKey__2__0 ?? (s_ThenByDescending__TSource_TKey__2__0 = new Func, Expression>, IOrderedAsyncQueryable>(ThenByDescending).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5218,7 +5218,7 @@ public static IOrderedAsyncQueryable ThenByDescending(th private static MethodInfo? s_ThenByDescending__TSource_TKey__3__0; - private static MethodInfo? ThenByDescending__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo ThenByDescending__TSource_TKey__3__0(Type TSource, Type TKey) => (s_ThenByDescending__TSource_TKey__3__0 ?? (s_ThenByDescending__TSource_TKey__3__0 = new Func, Expression>, IComparer, IOrderedAsyncQueryable>(ThenByDescending).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5234,7 +5234,7 @@ public static IOrderedAsyncQueryable ThenByDescending(th private static MethodInfo? s_ThenByDescendingAwait__TSource_TKey__2__0; - private static MethodInfo? ThenByDescendingAwait__TSource_TKey__2__0(Type TSource, Type TKey) => + private static MethodInfo ThenByDescendingAwait__TSource_TKey__2__0(Type TSource, Type TKey) => (s_ThenByDescendingAwait__TSource_TKey__2__0 ?? (s_ThenByDescendingAwait__TSource_TKey__2__0 = new Func, Expression>>, IOrderedAsyncQueryable>(ThenByDescendingAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5250,7 +5250,7 @@ public static IOrderedAsyncQueryable ThenByDescendingAwait + private static MethodInfo ThenByDescendingAwait__TSource_TKey__3__0(Type TSource, Type TKey) => (s_ThenByDescendingAwait__TSource_TKey__3__0 ?? (s_ThenByDescendingAwait__TSource_TKey__3__0 = new Func, Expression>>, IComparer, IOrderedAsyncQueryable>(ThenByDescendingAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5266,7 +5266,7 @@ public static IOrderedAsyncQueryable ThenByDescendingAwait + private static MethodInfo ThenByDescendingAwaitWithCancellation__TSource_TKey__2__0(Type TSource, Type TKey) => (s_ThenByDescendingAwaitWithCancellation__TSource_TKey__2__0 ?? (s_ThenByDescendingAwaitWithCancellation__TSource_TKey__2__0 = new Func, Expression>>, IOrderedAsyncQueryable>(ThenByDescendingAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5282,7 +5282,7 @@ public static IOrderedAsyncQueryable ThenByDescendingAwaitWithCancellat private static MethodInfo? s_ThenByDescendingAwaitWithCancellation__TSource_TKey__3__0; - private static MethodInfo? ThenByDescendingAwaitWithCancellation__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo ThenByDescendingAwaitWithCancellation__TSource_TKey__3__0(Type TSource, Type TKey) => (s_ThenByDescendingAwaitWithCancellation__TSource_TKey__3__0 ?? (s_ThenByDescendingAwaitWithCancellation__TSource_TKey__3__0 = new Func, Expression>>, IComparer, IOrderedAsyncQueryable>(ThenByDescendingAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5298,7 +5298,7 @@ public static IOrderedAsyncQueryable ThenByDescendingAwaitWithCancellat private static MethodInfo? s_ToArrayAsync__TSource__2__0; - private static MethodInfo? ToArrayAsync__TSource__2__0(Type TSource) => + private static MethodInfo ToArrayAsync__TSource__2__0(Type TSource) => (s_ToArrayAsync__TSource__2__0 ?? (s_ToArrayAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>(ToArrayAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5312,7 +5312,7 @@ public static ValueTask ToArrayAsync(this IAsyncQueryable + private static MethodInfo ToDictionaryAsync__TSource_TKey__3__0(Type TSource, Type TKey) => (s_ToDictionaryAsync__TSource_TKey__3__0 ?? (s_ToDictionaryAsync__TSource_TKey__3__0 = new Func, Expression>, CancellationToken, ValueTask>>(ToDictionaryAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5328,7 +5328,7 @@ public static ValueTask> ToDictionaryAsync + private static MethodInfo ToDictionaryAsync__TSource_TKey__4__0(Type TSource, Type TKey) => (s_ToDictionaryAsync__TSource_TKey__4__0 ?? (s_ToDictionaryAsync__TSource_TKey__4__0 = new Func, Expression>, IEqualityComparer, CancellationToken, ValueTask>>(ToDictionaryAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5344,7 +5344,7 @@ public static ValueTask> ToDictionaryAsync + private static MethodInfo ToDictionaryAsync__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => (s_ToDictionaryAsync__TSource_TKey_TElement__4__0 ?? (s_ToDictionaryAsync__TSource_TKey_TElement__4__0 = new Func, Expression>, Expression>, CancellationToken, ValueTask>>(ToDictionaryAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -5362,7 +5362,7 @@ public static ValueTask> ToDictionaryAsync + private static MethodInfo ToDictionaryAsync__TSource_TKey_TElement__5__0(Type TSource, Type TKey, Type TElement) => (s_ToDictionaryAsync__TSource_TKey_TElement__5__0 ?? (s_ToDictionaryAsync__TSource_TKey_TElement__5__0 = new Func, Expression>, Expression>, IEqualityComparer, CancellationToken, ValueTask>>(ToDictionaryAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -5380,7 +5380,7 @@ public static ValueTask> ToDictionaryAsync + private static MethodInfo ToDictionaryAwaitAsync__TSource_TKey__3__0(Type TSource, Type TKey) => (s_ToDictionaryAwaitAsync__TSource_TKey__3__0 ?? (s_ToDictionaryAwaitAsync__TSource_TKey__3__0 = new Func, Expression>>, CancellationToken, ValueTask>>(ToDictionaryAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5396,7 +5396,7 @@ public static ValueTask> ToDictionaryAwaitAsync + private static MethodInfo ToDictionaryAwaitAsync__TSource_TKey__4__0(Type TSource, Type TKey) => (s_ToDictionaryAwaitAsync__TSource_TKey__4__0 ?? (s_ToDictionaryAwaitAsync__TSource_TKey__4__0 = new Func, Expression>>, IEqualityComparer, CancellationToken, ValueTask>>(ToDictionaryAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5412,7 +5412,7 @@ public static ValueTask> ToDictionaryAwaitAsync + private static MethodInfo ToDictionaryAwaitAsync__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => (s_ToDictionaryAwaitAsync__TSource_TKey_TElement__4__0 ?? (s_ToDictionaryAwaitAsync__TSource_TKey_TElement__4__0 = new Func, Expression>>, Expression>>, CancellationToken, ValueTask>>(ToDictionaryAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -5430,7 +5430,7 @@ public static ValueTask> ToDictionaryAwaitAsync + private static MethodInfo ToDictionaryAwaitAsync__TSource_TKey_TElement__5__0(Type TSource, Type TKey, Type TElement) => (s_ToDictionaryAwaitAsync__TSource_TKey_TElement__5__0 ?? (s_ToDictionaryAwaitAsync__TSource_TKey_TElement__5__0 = new Func, Expression>>, Expression>>, IEqualityComparer, CancellationToken, ValueTask>>(ToDictionaryAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -5448,7 +5448,7 @@ public static ValueTask> ToDictionaryAwaitAsync + private static MethodInfo ToDictionaryAwaitWithCancellationAsync__TSource_TKey__3__0(Type TSource, Type TKey) => (s_ToDictionaryAwaitWithCancellationAsync__TSource_TKey__3__0 ?? (s_ToDictionaryAwaitWithCancellationAsync__TSource_TKey__3__0 = new Func, Expression>>, CancellationToken, ValueTask>>(ToDictionaryAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5464,7 +5464,7 @@ public static ValueTask> ToDictionaryAwaitWithCancella private static MethodInfo? s_ToDictionaryAwaitWithCancellationAsync__TSource_TKey__4__0; - private static MethodInfo? ToDictionaryAwaitWithCancellationAsync__TSource_TKey__4__0(Type TSource, Type TKey) => + private static MethodInfo ToDictionaryAwaitWithCancellationAsync__TSource_TKey__4__0(Type TSource, Type TKey) => (s_ToDictionaryAwaitWithCancellationAsync__TSource_TKey__4__0 ?? (s_ToDictionaryAwaitWithCancellationAsync__TSource_TKey__4__0 = new Func, Expression>>, IEqualityComparer, CancellationToken, ValueTask>>(ToDictionaryAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5480,7 +5480,7 @@ public static ValueTask> ToDictionaryAwaitWithCancella private static MethodInfo? s_ToDictionaryAwaitWithCancellationAsync__TSource_TKey_TElement__4__0; - private static MethodInfo? ToDictionaryAwaitWithCancellationAsync__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => + private static MethodInfo ToDictionaryAwaitWithCancellationAsync__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => (s_ToDictionaryAwaitWithCancellationAsync__TSource_TKey_TElement__4__0 ?? (s_ToDictionaryAwaitWithCancellationAsync__TSource_TKey_TElement__4__0 = new Func, Expression>>, Expression>>, CancellationToken, ValueTask>>(ToDictionaryAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -5498,7 +5498,7 @@ public static ValueTask> ToDictionaryAwaitWithCancell private static MethodInfo? s_ToDictionaryAwaitWithCancellationAsync__TSource_TKey_TElement__5__0; - private static MethodInfo? ToDictionaryAwaitWithCancellationAsync__TSource_TKey_TElement__5__0(Type TSource, Type TKey, Type TElement) => + private static MethodInfo ToDictionaryAwaitWithCancellationAsync__TSource_TKey_TElement__5__0(Type TSource, Type TKey, Type TElement) => (s_ToDictionaryAwaitWithCancellationAsync__TSource_TKey_TElement__5__0 ?? (s_ToDictionaryAwaitWithCancellationAsync__TSource_TKey_TElement__5__0 = new Func, Expression>>, Expression>>, IEqualityComparer, CancellationToken, ValueTask>>(ToDictionaryAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -5516,7 +5516,7 @@ public static ValueTask> ToDictionaryAwaitWithCancell private static MethodInfo? s_ToHashSetAsync__TSource__2__0; - private static MethodInfo? ToHashSetAsync__TSource__2__0(Type TSource) => + private static MethodInfo ToHashSetAsync__TSource__2__0(Type TSource) => (s_ToHashSetAsync__TSource__2__0 ?? (s_ToHashSetAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>>(ToHashSetAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5530,7 +5530,7 @@ public static ValueTask> ToHashSetAsync(this IAsyncQue private static MethodInfo? s_ToHashSetAsync__TSource__3__0; - private static MethodInfo? ToHashSetAsync__TSource__3__0(Type TSource) => + private static MethodInfo ToHashSetAsync__TSource__3__0(Type TSource) => (s_ToHashSetAsync__TSource__3__0 ?? (s_ToHashSetAsync__TSource__3__0 = new Func, IEqualityComparer, CancellationToken, ValueTask>>(ToHashSetAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5544,7 +5544,7 @@ public static ValueTask> ToHashSetAsync(this IAsyncQue private static MethodInfo? s_ToListAsync__TSource__2__0; - private static MethodInfo? ToListAsync__TSource__2__0(Type TSource) => + private static MethodInfo ToListAsync__TSource__2__0(Type TSource) => (s_ToListAsync__TSource__2__0 ?? (s_ToListAsync__TSource__2__0 = new Func, CancellationToken, ValueTask>>(ToListAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5558,7 +5558,7 @@ public static ValueTask> ToListAsync(this IAsyncQueryable private static MethodInfo? s_ToLookupAsync__TSource_TKey__3__0; - private static MethodInfo? ToLookupAsync__TSource_TKey__3__0(Type TSource, Type TKey) => + private static MethodInfo ToLookupAsync__TSource_TKey__3__0(Type TSource, Type TKey) => (s_ToLookupAsync__TSource_TKey__3__0 ?? (s_ToLookupAsync__TSource_TKey__3__0 = new Func, Expression>, CancellationToken, ValueTask>>(ToLookupAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5574,7 +5574,7 @@ public static ValueTask> ToLookupAsync(thi private static MethodInfo? s_ToLookupAsync__TSource_TKey__4__0; - private static MethodInfo? ToLookupAsync__TSource_TKey__4__0(Type TSource, Type TKey) => + private static MethodInfo ToLookupAsync__TSource_TKey__4__0(Type TSource, Type TKey) => (s_ToLookupAsync__TSource_TKey__4__0 ?? (s_ToLookupAsync__TSource_TKey__4__0 = new Func, Expression>, IEqualityComparer, CancellationToken, ValueTask>>(ToLookupAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5590,7 +5590,7 @@ public static ValueTask> ToLookupAsync(thi private static MethodInfo? s_ToLookupAsync__TSource_TKey_TElement__4__0; - private static MethodInfo? ToLookupAsync__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => + private static MethodInfo ToLookupAsync__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => (s_ToLookupAsync__TSource_TKey_TElement__4__0 ?? (s_ToLookupAsync__TSource_TKey_TElement__4__0 = new Func, Expression>, Expression>, CancellationToken, ValueTask>>(ToLookupAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -5608,7 +5608,7 @@ public static ValueTask> ToLookupAsync + private static MethodInfo ToLookupAsync__TSource_TKey_TElement__5__0(Type TSource, Type TKey, Type TElement) => (s_ToLookupAsync__TSource_TKey_TElement__5__0 ?? (s_ToLookupAsync__TSource_TKey_TElement__5__0 = new Func, Expression>, Expression>, IEqualityComparer, CancellationToken, ValueTask>>(ToLookupAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -5626,7 +5626,7 @@ public static ValueTask> ToLookupAsync + private static MethodInfo ToLookupAwaitAsync__TSource_TKey__3__0(Type TSource, Type TKey) => (s_ToLookupAwaitAsync__TSource_TKey__3__0 ?? (s_ToLookupAwaitAsync__TSource_TKey__3__0 = new Func, Expression>>, CancellationToken, ValueTask>>(ToLookupAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5642,7 +5642,7 @@ public static ValueTask> ToLookupAwaitAsync + private static MethodInfo ToLookupAwaitAsync__TSource_TKey__4__0(Type TSource, Type TKey) => (s_ToLookupAwaitAsync__TSource_TKey__4__0 ?? (s_ToLookupAwaitAsync__TSource_TKey__4__0 = new Func, Expression>>, IEqualityComparer, CancellationToken, ValueTask>>(ToLookupAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5658,7 +5658,7 @@ public static ValueTask> ToLookupAwaitAsync + private static MethodInfo ToLookupAwaitAsync__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => (s_ToLookupAwaitAsync__TSource_TKey_TElement__4__0 ?? (s_ToLookupAwaitAsync__TSource_TKey_TElement__4__0 = new Func, Expression>>, Expression>>, CancellationToken, ValueTask>>(ToLookupAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -5676,7 +5676,7 @@ public static ValueTask> ToLookupAwaitAsync + private static MethodInfo ToLookupAwaitAsync__TSource_TKey_TElement__5__0(Type TSource, Type TKey, Type TElement) => (s_ToLookupAwaitAsync__TSource_TKey_TElement__5__0 ?? (s_ToLookupAwaitAsync__TSource_TKey_TElement__5__0 = new Func, Expression>>, Expression>>, IEqualityComparer, CancellationToken, ValueTask>>(ToLookupAwaitAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -5694,7 +5694,7 @@ public static ValueTask> ToLookupAwaitAsync + private static MethodInfo ToLookupAwaitWithCancellationAsync__TSource_TKey__3__0(Type TSource, Type TKey) => (s_ToLookupAwaitWithCancellationAsync__TSource_TKey__3__0 ?? (s_ToLookupAwaitWithCancellationAsync__TSource_TKey__3__0 = new Func, Expression>>, CancellationToken, ValueTask>>(ToLookupAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5710,7 +5710,7 @@ public static ValueTask> ToLookupAwaitWithCancellationAsy private static MethodInfo? s_ToLookupAwaitWithCancellationAsync__TSource_TKey__4__0; - private static MethodInfo? ToLookupAwaitWithCancellationAsync__TSource_TKey__4__0(Type TSource, Type TKey) => + private static MethodInfo ToLookupAwaitWithCancellationAsync__TSource_TKey__4__0(Type TSource, Type TKey) => (s_ToLookupAwaitWithCancellationAsync__TSource_TKey__4__0 ?? (s_ToLookupAwaitWithCancellationAsync__TSource_TKey__4__0 = new Func, Expression>>, IEqualityComparer, CancellationToken, ValueTask>>(ToLookupAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey); @@ -5726,7 +5726,7 @@ public static ValueTask> ToLookupAwaitWithCancellationAsy private static MethodInfo? s_ToLookupAwaitWithCancellationAsync__TSource_TKey_TElement__4__0; - private static MethodInfo? ToLookupAwaitWithCancellationAsync__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => + private static MethodInfo ToLookupAwaitWithCancellationAsync__TSource_TKey_TElement__4__0(Type TSource, Type TKey, Type TElement) => (s_ToLookupAwaitWithCancellationAsync__TSource_TKey_TElement__4__0 ?? (s_ToLookupAwaitWithCancellationAsync__TSource_TKey_TElement__4__0 = new Func, Expression>>, Expression>>, CancellationToken, ValueTask>>(ToLookupAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -5744,7 +5744,7 @@ public static ValueTask> ToLookupAwaitWithCancellationAs private static MethodInfo? s_ToLookupAwaitWithCancellationAsync__TSource_TKey_TElement__5__0; - private static MethodInfo? ToLookupAwaitWithCancellationAsync__TSource_TKey_TElement__5__0(Type TSource, Type TKey, Type TElement) => + private static MethodInfo ToLookupAwaitWithCancellationAsync__TSource_TKey_TElement__5__0(Type TSource, Type TKey, Type TElement) => (s_ToLookupAwaitWithCancellationAsync__TSource_TKey_TElement__5__0 ?? (s_ToLookupAwaitWithCancellationAsync__TSource_TKey_TElement__5__0 = new Func, Expression>>, Expression>>, IEqualityComparer, CancellationToken, ValueTask>>(ToLookupAwaitWithCancellationAsync).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource, TKey, TElement); @@ -5762,7 +5762,7 @@ public static ValueTask> ToLookupAwaitWithCancellationAs private static MethodInfo? s_Union__TSource__2__0; - private static MethodInfo? Union__TSource__2__0(Type TSource) => + private static MethodInfo Union__TSource__2__0(Type TSource) => (s_Union__TSource__2__0 ?? (s_Union__TSource__2__0 = new Func, IAsyncEnumerable, IAsyncQueryable>(Union).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5778,7 +5778,7 @@ public static IAsyncQueryable Union(this IAsyncQueryable + private static MethodInfo Union__TSource__3__0(Type TSource) => (s_Union__TSource__3__0 ?? (s_Union__TSource__3__0 = new Func, IAsyncEnumerable, IEqualityComparer, IAsyncQueryable>(Union).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5794,7 +5794,7 @@ public static IAsyncQueryable Union(this IAsyncQueryable + private static MethodInfo Where__TSource__2__0(Type TSource) => (s_Where__TSource__2__0 ?? (s_Where__TSource__2__0 = new Func, Expression>, IAsyncQueryable>(Where).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5810,7 +5810,7 @@ public static IAsyncQueryable Where(this IAsyncQueryable + private static MethodInfo Where__TSource__2__1(Type TSource) => (s_Where__TSource__2__1 ?? (s_Where__TSource__2__1 = new Func, Expression>, IAsyncQueryable>(Where).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5826,7 +5826,7 @@ public static IAsyncQueryable Where(this IAsyncQueryable + private static MethodInfo WhereAwait__TSource__2__0(Type TSource) => (s_WhereAwait__TSource__2__0 ?? (s_WhereAwait__TSource__2__0 = new Func, Expression>>, IAsyncQueryable>(WhereAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5842,7 +5842,7 @@ public static IAsyncQueryable WhereAwait(this IAsyncQueryable< private static MethodInfo? s_WhereAwait__TSource__2__1; - private static MethodInfo? WhereAwait__TSource__2__1(Type TSource) => + private static MethodInfo WhereAwait__TSource__2__1(Type TSource) => (s_WhereAwait__TSource__2__1 ?? (s_WhereAwait__TSource__2__1 = new Func, Expression>>, IAsyncQueryable>(WhereAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5858,7 +5858,7 @@ public static IAsyncQueryable WhereAwait(this IAsyncQueryable< private static MethodInfo? s_WhereAwaitWithCancellation__TSource__2__0; - private static MethodInfo? WhereAwaitWithCancellation__TSource__2__0(Type TSource) => + private static MethodInfo WhereAwaitWithCancellation__TSource__2__0(Type TSource) => (s_WhereAwaitWithCancellation__TSource__2__0 ?? (s_WhereAwaitWithCancellation__TSource__2__0 = new Func, Expression>>, IAsyncQueryable>(WhereAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5874,7 +5874,7 @@ public static IAsyncQueryable WhereAwaitWithCancellation(this private static MethodInfo? s_WhereAwaitWithCancellation__TSource__2__1; - private static MethodInfo? WhereAwaitWithCancellation__TSource__2__1(Type TSource) => + private static MethodInfo WhereAwaitWithCancellation__TSource__2__1(Type TSource) => (s_WhereAwaitWithCancellation__TSource__2__1 ?? (s_WhereAwaitWithCancellation__TSource__2__1 = new Func, Expression>>, IAsyncQueryable>(WhereAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TSource); @@ -5888,9 +5888,25 @@ public static IAsyncQueryable WhereAwaitWithCancellation(this return source.Provider.CreateQuery(Expression.Call(WhereAwaitWithCancellation__TSource__2__1(typeof(TSource)), source.Expression, predicate)); } + private static MethodInfo? s_Zip__TFirst_TSecond__2__0; + + private static MethodInfo Zip__TFirst_TSecond__2__0(Type TFirst, Type TSecond) => + (s_Zip__TFirst_TSecond__2__0 ?? + (s_Zip__TFirst_TSecond__2__0 = new Func, IAsyncEnumerable, IAsyncQueryable>>(Zip).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TFirst, TSecond); + + public static IAsyncQueryable> Zip(this IAsyncQueryable first, IAsyncEnumerable second) + { + if (first == null) + throw new ArgumentNullException(nameof(first)); + if (second == null) + throw new ArgumentNullException(nameof(second)); + + return first.Provider.CreateQuery>(Expression.Call(Zip__TFirst_TSecond__2__0(typeof(TFirst), typeof(TSecond)), first.Expression, GetSourceExpression(second))); + } + private static MethodInfo? s_Zip__TFirst_TSecond_TResult__3__0; - private static MethodInfo? Zip__TFirst_TSecond_TResult__3__0(Type TFirst, Type TSecond, Type TResult) => + private static MethodInfo Zip__TFirst_TSecond_TResult__3__0(Type TFirst, Type TSecond, Type TResult) => (s_Zip__TFirst_TSecond_TResult__3__0 ?? (s_Zip__TFirst_TSecond_TResult__3__0 = new Func, IAsyncEnumerable, Expression>, IAsyncQueryable>(Zip).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TFirst, TSecond, TResult); @@ -5908,7 +5924,7 @@ public static IAsyncQueryable Zip(this IAsync private static MethodInfo? s_ZipAwait__TFirst_TSecond_TResult__3__0; - private static MethodInfo? ZipAwait__TFirst_TSecond_TResult__3__0(Type TFirst, Type TSecond, Type TResult) => + private static MethodInfo ZipAwait__TFirst_TSecond_TResult__3__0(Type TFirst, Type TSecond, Type TResult) => (s_ZipAwait__TFirst_TSecond_TResult__3__0 ?? (s_ZipAwait__TFirst_TSecond_TResult__3__0 = new Func, IAsyncEnumerable, Expression>>, IAsyncQueryable>(ZipAwait).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TFirst, TSecond, TResult); @@ -5926,7 +5942,7 @@ public static IAsyncQueryable ZipAwait(this I private static MethodInfo? s_ZipAwaitWithCancellation__TFirst_TSecond_TResult__3__0; - private static MethodInfo? ZipAwaitWithCancellation__TFirst_TSecond_TResult__3__0(Type TFirst, Type TSecond, Type TResult) => + private static MethodInfo ZipAwaitWithCancellation__TFirst_TSecond_TResult__3__0(Type TFirst, Type TSecond, Type TResult) => (s_ZipAwaitWithCancellation__TFirst_TSecond_TResult__3__0 ?? (s_ZipAwaitWithCancellation__TFirst_TSecond_TResult__3__0 = new Func, IAsyncEnumerable, Expression>>, IAsyncQueryable>(ZipAwaitWithCancellation).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TFirst, TSecond, TResult); diff --git a/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.Generated.tt b/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.Generated.tt index 0bf5885ce2..4fa928e9d0 100644 --- a/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.Generated.tt +++ b/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.Generated.tt @@ -3,9 +3,9 @@ // See the LICENSE file in the project root for more information. <#@ template debug="false" hostspecific="false" language="C#" #> -<#@ assembly name="$(ProjectDir)\..\System.Linq.Async\bin\$(Configuration)\net461\Microsoft.Bcl.AsyncInterfaces.dll" #> -<#@ assembly name="$(ProjectDir)\..\System.Linq.Async\bin\$(Configuration)\net461\System.Threading.Tasks.Extensions.dll" #> -<#@ assembly name="$(ProjectDir)\..\System.Linq.Async\bin\$(Configuration)\net461\System.Linq.Async.dll" #> +<#@ assembly name="$(ProjectDir)\..\System.Linq.Async\bin\$(Configuration)\net48\Microsoft.Bcl.AsyncInterfaces.dll" #> +<#@ assembly name="$(ProjectDir)\..\System.Linq.Async\bin\$(Configuration)\net48\System.Threading.Tasks.Extensions.dll" #> +<#@ assembly name="$(ProjectDir)\..\System.Linq.Async\bin\$(Configuration)\net48\System.Linq.Async.dll" #> <#@ output extension=".cs" #> <# var asyncEnumerableType = typeof(AsyncEnumerable); diff --git a/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.cs b/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.cs index 5d206944c0..2b621d88c1 100644 --- a/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.cs +++ b/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncQueryable.cs @@ -34,22 +34,6 @@ public static IAsyncQueryable AsAsyncQueryable(this IAsyncEn return new AsyncEnumerableQuery(source); } - private static MethodInfo? s_Zip__TFirst_TSecond__2__0; - - private static MethodInfo Zip__TFirst_TSecond__2__0(Type TFirst, Type TSecond) => - (s_Zip__TFirst_TSecond__2__0 ?? - (s_Zip__TFirst_TSecond__2__0 = new Func, IAsyncEnumerable, IAsyncQueryable>>(Zip).GetMethodInfo()!.GetGenericMethodDefinition())).MakeGenericMethod(TFirst, TSecond); - - public static IAsyncQueryable<(TFirst First, TSecond Second)> Zip(this IAsyncQueryable first, IAsyncEnumerable second) - { - if (first == null) - throw new ArgumentNullException(nameof(first)); - if (second == null) - throw new ArgumentNullException(nameof(second)); - - return first.Provider.CreateQuery<(TFirst, TSecond)>(Expression.Call(Zip__TFirst_TSecond__2__0(typeof(TFirst), typeof(TSecond)), first.Expression, GetSourceExpression(second))); - } - private static Expression GetSourceExpression(IAsyncEnumerable source) { if (source is IAsyncQueryable queryable) diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj b/Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj index ec7e2d5e46..485142606b 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj +++ b/Ix.NET/Source/System.Linq.Async.Tests/System.Linq.Async.Tests.csproj @@ -1,8 +1,15 @@  - net48;net6.0;netcoreapp3.1 - $(NoWarn);CS0618;CS8603;CS8625 + + net48;net8.0;net6.0;netcoreapp3.1 + + + + $(NoWarn);CS0618;CS8603;CS8625;CA1510;CA1822;CA1861 diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Aggregate.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Aggregate.cs index 6b225a7b06..6dd39e3646 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Aggregate.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Aggregate.cs @@ -47,7 +47,7 @@ public async Task AggregateAsync_Simple() [Fact] public async Task AggregateAsync_Empty() { - var xs = new int[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); var ys = xs.AggregateAsync((x, y) => x * y); await AssertThrowsAsync(ys.AsTask()); } @@ -81,7 +81,7 @@ public async Task AggregateAsync_Seed_Simple() [Fact] public async Task AggregateAsync_Seed_Emtpy() { - var xs = new int[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); var ys = xs.AggregateAsync(1, (x, y) => x * y); Assert.Equal(1, await ys); } @@ -115,7 +115,7 @@ public async Task AggregateAsync_Seed_Result_Simple() [Fact] public async Task AggregateAsync_Seed_Result_Empty() { - var xs = new int[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); var ys = xs.AggregateAsync(1, (x, y) => x * y, x => x + 1); Assert.Equal(2, await ys); } @@ -182,7 +182,7 @@ public async Task AggregateAwaitAsync_Simple() [Fact] public async Task AggregateAwaitAsync_Empty() { - var xs = new int[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); var ys = xs.AggregateAwaitAsync((x, y) => new ValueTask(x * y)); await AssertThrowsAsync(ys.AsTask()); } @@ -216,7 +216,7 @@ public async Task AggregateAwaitAsync_Seed_Simple() [Fact] public async Task AggregateAwaitAsync_Seed_Emtpy() { - var xs = new int[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); var ys = xs.AggregateAwaitAsync(1, (x, y) => new ValueTask(x * y)); Assert.Equal(1, await ys); } @@ -250,7 +250,7 @@ public async Task AggregateAwaitAsync_Seed_Result_Simple() [Fact] public async Task AggregateAwaitAsync_Seed_Result_Empty() { - var xs = new int[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); var ys = xs.AggregateAwaitAsync(1, (x, y) => new ValueTask(x * y), x => new ValueTask(x + 1)); Assert.Equal(2, await ys); } @@ -318,7 +318,7 @@ public async Task AggregateAwaitWithCancellationAsync_Simple() [Fact] public async Task AggregateAwaitWithCancellationAsync_Empty() { - var xs = new int[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); var ys = xs.AggregateAwaitWithCancellationAsync((x, y, ct) => new ValueTask(x * y)); await AssertThrowsAsync(ys.AsTask()); } @@ -352,7 +352,7 @@ public async Task AggregateAwaitWithCancellationAsync_Seed_Simple() [Fact] public async Task AggregateAwaitWithCancellationAsync_Seed_Emtpy() { - var xs = new int[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); var ys = xs.AggregateAwaitWithCancellationAsync(1, (x, y, ct) => new ValueTask(x * y)); Assert.Equal(1, await ys); } @@ -386,7 +386,7 @@ public async Task AggregateAwaitWithCancellationAsync_Seed_Result_Simple() [Fact] public async Task AggregateAwaitWithCancellationAsync_Seed_Result_Empty() { - var xs = new int[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); var ys = xs.AggregateAwaitWithCancellationAsync(1, (x, y, ct) => new ValueTask(x * y), (x, ct) => new ValueTask(x + 1)); Assert.Equal(2, await ys); } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Any.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Any.cs index 29db08827f..b031e0214f 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Any.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Any.cs @@ -65,7 +65,7 @@ public async Task AnyAsync_NoSelector_NonEmpty() [Fact] public async Task AnyAsync_NoSelector_Empty() { - var res = new int[0].ToAsyncEnumerable().AnyAsync(); + var res = Array.Empty().ToAsyncEnumerable().AnyAsync(); Assert.False(await res); } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Count.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Count.cs index f9aa8b0c9c..f17971140e 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Count.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Count.cs @@ -22,7 +22,7 @@ public async Task CountAsync_Simple_Null() [Fact] public async Task CountAsync_Simple() { - Assert.Equal(0, await new int[0].ToAsyncEnumerable().CountAsync()); + Assert.Equal(0, await Array.Empty().ToAsyncEnumerable().CountAsync()); Assert.Equal(3, await new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync()); } @@ -46,7 +46,7 @@ public async Task CountAsync_Predicate_Null() [Fact] public async Task CountAsync_Predicate() { - Assert.Equal(0, await new int[0].ToAsyncEnumerable().CountAsync(x => x < 3)); + Assert.Equal(0, await Array.Empty().ToAsyncEnumerable().CountAsync(x => x < 3)); Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAsync(x => x < 3)); } @@ -78,7 +78,7 @@ public async Task CountAwaitAsync_Null() [Fact] public async Task CountAwaitAsync() { - Assert.Equal(0, await new int[0].ToAsyncEnumerable().CountAwaitAsync(x => new ValueTask(x < 3))); + Assert.Equal(0, await Array.Empty().ToAsyncEnumerable().CountAwaitAsync(x => new ValueTask(x < 3))); Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAwaitAsync(x => new ValueTask(x < 3))); } @@ -111,7 +111,7 @@ public async Task CountAwaitWithCancellationAsync_Null() [Fact] public async Task CountAwaitWithCancellationAsync() { - Assert.Equal(0, await new int[0].ToAsyncEnumerable().CountAwaitWithCancellationAsync((x, ct) => new ValueTask(x < 3))); + Assert.Equal(0, await Array.Empty().ToAsyncEnumerable().CountAwaitWithCancellationAsync((x, ct) => new ValueTask(x < 3))); Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().CountAwaitWithCancellationAsync((x, ct) => new ValueTask(x < 3))); } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/First.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/First.cs index a00ac81c7b..8c1278cbc7 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/First.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/First.cs @@ -29,14 +29,14 @@ public async Task FirstAsync_NoParam_Empty() [Fact] public async Task FirstAsync_NoParam_Empty_Enumerable() { - var res = new int[0].Select(x => x).ToAsyncEnumerable().FirstAsync(); + var res = Array.Empty().Select(x => x).ToAsyncEnumerable().FirstAsync(); await AssertThrowsAsync(res.AsTask()); } [Fact] public async Task FirstAsync_NoParam_Empty_IList() { - var res = new int[0].ToAsyncEnumerable().FirstAsync(); + var res = Array.Empty().ToAsyncEnumerable().FirstAsync(); await AssertThrowsAsync(res.AsTask()); } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/FirstOrDefault.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/FirstOrDefault.cs index 1719c9ecf5..39c3ea3fe6 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/FirstOrDefault.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/FirstOrDefault.cs @@ -29,14 +29,14 @@ public async Task FirstOrDefaultAsync_NoParam_Empty() [Fact] public async Task FirstOrDefaultAsync_NoParam_Empty_Enumerable() { - var res = new int[0].Select(x => x).ToAsyncEnumerable().FirstOrDefaultAsync(); + var res = Array.Empty().Select(x => x).ToAsyncEnumerable().FirstOrDefaultAsync(); Assert.Equal(0, await res); } [Fact] public async Task FirstOrDefaultAsync_NoParam_Empty_IList() { - var res = new int[0].ToAsyncEnumerable().FirstOrDefaultAsync(); + var res = Array.Empty().ToAsyncEnumerable().FirstOrDefaultAsync(); Assert.Equal(0, await res); } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/GroupBy.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/GroupBy.cs index 301df97e2e..1d7d6b4a91 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/GroupBy.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/GroupBy.cs @@ -2,6 +2,10 @@ // The .NET Foundation licenses this file to you under the MIT License. // See the LICENSE file in the project root for more information. +#if NET6_0_OR_GREATER +#pragma warning disable CA2012 // Use ValueTasks correctly. These tests need to use Result to verify correct operation, so we can't avoid breaking this rule. +#endif + using System; using System.Collections.Generic; using System.Linq; @@ -826,7 +830,7 @@ public Kvp(string key, int item) public string Key { get; } public int Item { get; } - public bool Equals(Kvp other) + public bool Equals(Kvp? other) { if (other is null) return false; if (ReferenceEquals(this, other)) return true; diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/GroupJoin.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/GroupJoin.cs index 87eed9ddc3..aa9d5b70c5 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/GroupJoin.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/GroupJoin.cs @@ -2,6 +2,10 @@ // The .NET Foundation licenses this file to you under the MIT License. // See the LICENSE file in the project root for more information. +#if NET6_0_OR_GREATER +#pragma warning disable CA2012 // Use ValueTasks correctly. These tests need to use Result to verify correct operation, so we can't avoid breaking this rule. +#endif + using System; using System.Collections.Generic; using System.Linq; diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Join.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Join.cs index 13c4f7aeff..931e5f0e02 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Join.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Join.cs @@ -167,19 +167,19 @@ public async Task Join11() { var customers = new List { - new Customer { CustomerId = "ALFKI" }, - new Customer { CustomerId = "ANANT" }, - new Customer { CustomerId = "FISSA" }, + new() { CustomerId = "ALFKI" }, + new() { CustomerId = "ANANT" }, + new() { CustomerId = "FISSA" }, }; var orders = new List { - new Order { OrderId = 1, CustomerId = "ALFKI"}, - new Order { OrderId = 2, CustomerId = "ALFKI"}, - new Order { OrderId = 3, CustomerId = "ALFKI"}, - new Order { OrderId = 4, CustomerId = "FISSA"}, - new Order { OrderId = 5, CustomerId = "FISSA"}, - new Order { OrderId = 6, CustomerId = "FISSA"}, + new() { OrderId = 1, CustomerId = "ALFKI"}, + new() { OrderId = 2, CustomerId = "ALFKI"}, + new() { OrderId = 3, CustomerId = "ALFKI"}, + new() { OrderId = 4, CustomerId = "FISSA"}, + new() { OrderId = 5, CustomerId = "FISSA"}, + new() { OrderId = 6, CustomerId = "FISSA"}, }; var asyncResult = customers.ToAsyncEnumerable() @@ -201,18 +201,18 @@ public async Task Join12() { var customers = new List { - new Customer {CustomerId = "ANANT"}, - new Customer {CustomerId = "ALFKI"}, - new Customer {CustomerId = "FISSA"} + new() {CustomerId = "ANANT"}, + new() {CustomerId = "ALFKI"}, + new() {CustomerId = "FISSA"} }; var orders = new List { - new Order { OrderId = 1, CustomerId = "ALFKI"}, - new Order { OrderId = 2, CustomerId = "ALFKI"}, - new Order { OrderId = 3, CustomerId = "ALFKI"}, - new Order { OrderId = 4, CustomerId = "FISSA"}, - new Order { OrderId = 5, CustomerId = "FISSA"}, - new Order { OrderId = 6, CustomerId = "FISSA"}, + new() { OrderId = 1, CustomerId = "ALFKI"}, + new() { OrderId = 2, CustomerId = "ALFKI"}, + new() { OrderId = 3, CustomerId = "ALFKI"}, + new() { OrderId = 4, CustomerId = "FISSA"}, + new() { OrderId = 5, CustomerId = "FISSA"}, + new() { OrderId = 6, CustomerId = "FISSA"}, }; var asyncResult = customers.ToAsyncEnumerable() @@ -245,7 +245,7 @@ public class CustomerOrder : IEquatable public int OrderId { get; set; } public string? CustomerId { get; set; } - public bool Equals(CustomerOrder other) + public bool Equals(CustomerOrder? other) { if (other is null) return false; if (ReferenceEquals(this, other)) return true; diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Last.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Last.cs index 2c42f4c3ff..bd7ac81084 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Last.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Last.cs @@ -29,14 +29,14 @@ public async Task LastAsync_NoParam_Empty() [Fact] public async Task LastAsync_NoParam_Empty_Enumerable() { - var res = new int[0].Select(x => x).ToAsyncEnumerable().LastAsync(); + var res = Array.Empty().Select(x => x).ToAsyncEnumerable().LastAsync(); await AssertThrowsAsync(res.AsTask()); } [Fact] public async Task LastAsync_NoParam_Empty_IList() { - var res = new int[0].ToAsyncEnumerable().LastAsync(); + var res = Array.Empty().ToAsyncEnumerable().LastAsync(); await AssertThrowsAsync(res.AsTask()); } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/LastOrDefault.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/LastOrDefault.cs index 13449f6933..eef94d446c 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/LastOrDefault.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/LastOrDefault.cs @@ -29,14 +29,14 @@ public async Task LastOrDefaultAsync_NoParam_Empty() [Fact] public async Task LasyOrDefaultAsync_NoParam_Empty_Enumerable() { - var res = new int[0].Select(x => x).ToAsyncEnumerable().LastOrDefaultAsync(); + var res = Array.Empty().Select(x => x).ToAsyncEnumerable().LastOrDefaultAsync(); Assert.Equal(0, await res); } [Fact] public async Task LastOrDefaultAsync_NoParam_Empty_IList() { - var res = new int[0].ToAsyncEnumerable().LastOrDefaultAsync(); + var res = Array.Empty().ToAsyncEnumerable().LastOrDefaultAsync(); Assert.Equal(0, await res); } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/LongCount.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/LongCount.cs index a994b70e1d..4a7cd5c8b4 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/LongCount.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/LongCount.cs @@ -22,7 +22,7 @@ public async Task LongCountAsync_Simple_Null() [Fact] public async Task LongCountAsync_Simple() { - Assert.Equal(0, await new int[0].ToAsyncEnumerable().LongCountAsync()); + Assert.Equal(0, await Array.Empty().ToAsyncEnumerable().LongCountAsync()); Assert.Equal(3, await new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCountAsync()); } @@ -46,7 +46,7 @@ public async Task LongCountAsync_Predicate_Null() [Fact] public async Task LongCountAsync_Predicate_Simple() { - Assert.Equal(0, await new int[0].ToAsyncEnumerable().LongCountAsync(x => x < 3)); + Assert.Equal(0, await Array.Empty().ToAsyncEnumerable().LongCountAsync(x => x < 3)); Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCountAsync(x => x < 3)); } @@ -78,7 +78,7 @@ public async Task LongCountAwaitAsync_Predicate_Null() [Fact] public async Task LongCountAwaitAsync_Predicate() { - Assert.Equal(0, await new int[0].ToAsyncEnumerable().LongCountAwaitAsync(x => new ValueTask(x < 3))); + Assert.Equal(0, await Array.Empty().ToAsyncEnumerable().LongCountAwaitAsync(x => new ValueTask(x < 3))); Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCountAwaitAsync(x => new ValueTask(x < 3))); } @@ -111,7 +111,7 @@ public async Task LongCountAwaitWithCancellationAsync_Predicate_Null() [Fact] public async Task LongCountAwaitWithCancellationAsync_Predicate() { - Assert.Equal(0, await new int[0].ToAsyncEnumerable().LongCountAwaitWithCancellationAsync((x, ct) => new ValueTask(x < 3))); + Assert.Equal(0, await Array.Empty().ToAsyncEnumerable().LongCountAwaitWithCancellationAsync((x, ct) => new ValueTask(x < 3))); Assert.Equal(2, await new[] { 1, 2, 3 }.ToAsyncEnumerable().LongCountAwaitWithCancellationAsync((x, ct) => new ValueTask(x < 3))); } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Max.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Max.cs index 0fdc36a867..51abfd0165 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Max.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Max.cs @@ -359,7 +359,7 @@ public async Task MaxAsync_TSource_NonValue() [Fact] public async Task MaxAsync_TSource_Value_Empty() { - var xs = new DateTimeOffset[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); await AssertThrowsAsync(xs.MaxAsync().AsTask()); await AssertThrowsAsync(xs.MaxAsync(x => x).AsTask()); await AssertThrowsAsync(xs.MaxAwaitAsync(x => new ValueTask(x)).AsTask()); @@ -371,7 +371,7 @@ public async Task MaxAsync_TSource_Value_Empty() [Fact] public async Task MaxAsync_TSource_NonValue_Empty() { - var xs = new string[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); Assert.Null(await xs.MaxAsync()); Assert.Null(await xs.MaxAsync(x => x)); Assert.Null(await xs.MaxAwaitAsync(x => new ValueTask(x))); @@ -383,7 +383,7 @@ public async Task MaxAsync_TSource_NonValue_Empty() [Fact] public async Task MaxAsync_TSource_NullableValue_Empty() { - var xs = new DateTimeOffset?[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); Assert.Null(await xs.MaxAsync()); Assert.Null(await xs.MaxAsync(x => x)); Assert.Null(await xs.MaxAwaitAsync(x => new ValueTask(x))); diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Min.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Min.cs index 7e9e377451..b1d12cc0fd 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Min.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Min.cs @@ -359,7 +359,7 @@ public async Task MinAsync_TSource_NonValue() [Fact] public async Task MinAsync_TSource_Value_Empty() { - var xs = new DateTimeOffset[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); await AssertThrowsAsync(xs.MinAsync().AsTask()); await AssertThrowsAsync(xs.MinAsync(x => x).AsTask()); await AssertThrowsAsync(xs.MinAwaitAsync(x => new ValueTask(x)).AsTask()); @@ -371,7 +371,7 @@ public async Task MinAsync_TSource_Value_Empty() [Fact] public async Task MinAsync_TSource_NonValue_Empty() { - var xs = new string[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); Assert.Null(await xs.MinAsync()); Assert.Null(await xs.MinAsync(x => x)); Assert.Null(await xs.MinAwaitAsync(x => new ValueTask(x))); @@ -383,7 +383,7 @@ public async Task MinAsync_TSource_NonValue_Empty() [Fact] public async Task MinAsync_TSource_NullableValue_Empty() { - var xs = new DateTimeOffset?[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); Assert.Null(await xs.MinAsync()); Assert.Null(await xs.MinAsync(x => x)); Assert.Null(await xs.MinAwaitAsync(x => new ValueTask(x))); diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Range.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Range.cs index c0008c5208..1b27d1ed01 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Range.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Range.cs @@ -63,7 +63,7 @@ public async Task Range_Simple_IAsyncPartition() Assert.Equal(2, await xs.Take(1024).FirstAsync()); Assert.Equal(6, await xs.Take(1024).LastAsync()); - Assert.Equal(new[] { 2, 3, 4, 5, 6 }, await xs.ToArrayAsync()); + Assert.Equal([2, 3, 4, 5, 6], await xs.ToArrayAsync()); Assert.Equal(new[] { 2, 3, 4, 5, 6 }, await xs.ToListAsync()); } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Reverse.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Reverse.cs index 40a0e6df39..aacf431da1 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Reverse.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Reverse.cs @@ -68,7 +68,7 @@ public async Task Reverse5() var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); var ys = xs.Reverse(); - Assert.Equal(new[] { 3, 2, 1 }, await ys.ToArrayAsync()); + Assert.Equal([3, 2, 1], await ys.ToArrayAsync()); } [Fact] @@ -104,7 +104,7 @@ public async Task Reverse9() var xs = new[] { 1, 2, 3 }.ToAsyncEnumerable(); var ys = xs.Reverse().Prepend(4); // to trigger onlyIfCheap - Assert.Equal(new[] { 4, 3, 2, 1 }, await ys.ToArrayAsync()); + Assert.Equal([4, 3, 2, 1], await ys.ToArrayAsync()); } } } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Select.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Select.cs index 8a773bdc90..65db9e8de8 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Select.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Select.cs @@ -26,7 +26,7 @@ public void Select_Sync_Null() [Fact] public async Task Select_Sync_Simple() { - var xs = ToAsyncEnumerable(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerable([0, 1, 2]); var ys = xs.Select(x => (char)('a' + x)); var e = ys.GetAsyncEnumerator(); @@ -39,7 +39,7 @@ public async Task Select_Sync_Simple() [Fact] public async Task Select_Sync_Simple_IList() { - var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerableIList([0, 1, 2]); var ys = xs.Select(x => (char)('a' + x)); var e = ys.GetAsyncEnumerator(); @@ -65,7 +65,7 @@ public async Task Select_Sync_Simple_AsyncIterator() [Fact] public async Task Select_Sync_Indexed() { - var xs = ToAsyncEnumerable(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerable([8, 5, 7]); var ys = xs.Select((x, i) => (char)('a' + i)); var e = ys.GetAsyncEnumerator(); @@ -78,7 +78,7 @@ public async Task Select_Sync_Indexed() [Fact] public async Task Select_Sync_Indexed_IList() { - var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerableIList([8, 5, 7]); var ys = xs.Select((x, i) => (char)('a' + i)); var e = ys.GetAsyncEnumerator(); @@ -104,7 +104,7 @@ public async Task Select_Sync_Indexed_AsyncIterator() [Fact] public async Task Select_Sync_Throws_Selector() { - var xs = ToAsyncEnumerable(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerable([0, 1, 2]); var ys = xs.Select(x => 1 / x); var e = ys.GetAsyncEnumerator(); @@ -114,7 +114,7 @@ public async Task Select_Sync_Throws_Selector() [Fact] public async Task Select_Sync_Throws_Selector_IList() { - var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerableIList([0, 1, 2]); var ys = xs.Select(x => 1 / x); var e = ys.GetAsyncEnumerator(); @@ -134,7 +134,7 @@ public async Task Select_Sync_Throws_Selector_AsyncIterator() [Fact] public async Task Select_Sync_Indexed_Throws_Selector() { - var xs = ToAsyncEnumerable(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerable([8, 5, 7]); var ys = xs.Select((x, i) => 1 / i); var e = ys.GetAsyncEnumerator(); @@ -144,7 +144,7 @@ public async Task Select_Sync_Indexed_Throws_Selector() [Fact] public async Task Select_Sync_Indexed_Throws_Selector_IList() { - var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerableIList([8, 5, 7]); var ys = xs.Select((x, i) => 1 / i); var e = ys.GetAsyncEnumerator(); @@ -164,7 +164,7 @@ public async Task Select_Sync_Indexed_Throws_Selector_AsyncIterator() [Fact] public async Task Select_Sync_SelectSelect() { - var xs = ToAsyncEnumerable(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerable([0, 1, 2]); var ys = xs.Select(i => i + 3).Select(x => (char)('a' + x)); var e = ys.GetAsyncEnumerator(); @@ -177,7 +177,7 @@ public async Task Select_Sync_SelectSelect() [Fact] public async Task Select_Sync_SelectSelect_IList() { - var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerableIList([0, 1, 2]); var ys = xs.Select(i => i + 3).Select(x => (char)('a' + x)); var e = ys.GetAsyncEnumerator(); @@ -203,7 +203,7 @@ public async Task Select_Sync_SelectSelectAwaitIterator() [Fact] public async Task Select_Sync_SequenceIdentity() { - var xs = ToAsyncEnumerable(new[] { 1, 2, 3 }); + var xs = ToAsyncEnumerable([1, 2, 3]); var ys = xs.Select(x => (char)('a' + x)); await SequenceIdentity(ys); @@ -212,7 +212,7 @@ public async Task Select_Sync_SequenceIdentity() [Fact] public async Task Select_Sync_SequenceIdentity_IList() { - var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3 }); + var xs = ToAsyncEnumerableIList([1, 2, 3]); var ys = xs.Select(x => (char)('a' + x)); await SequenceIdentity(ys); @@ -230,7 +230,7 @@ public async Task Select_Sync_SequenceIdentity_AsyncIterator() [Fact] public async Task Select_Sync_Indexed_SequenceIdentity() { - var xs = ToAsyncEnumerable(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerable([8, 5, 7]); var ys = xs.Select((x, i) => (char)('a' + i)); await SequenceIdentity(ys); @@ -239,7 +239,7 @@ public async Task Select_Sync_Indexed_SequenceIdentity() [Fact] public async Task Select_Sync_Indexed_SequenceIdentity_IList() { - var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerableIList([8, 5, 7]); var ys = xs.Select((x, i) => (char)('a' + i)); await SequenceIdentity(ys); @@ -257,7 +257,7 @@ public async Task Select_Sync_Indexed_SequenceIdentity_AsyncIterator() [Fact] public async Task Select_Sync_IList_Count() { - var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 }); + var xs = ToAsyncEnumerableIList([1, 2, 3, 4, 5]); var ys = xs.Select(x => x * 2); Assert.Equal(5, await ys.CountAsync()); @@ -266,7 +266,7 @@ public async Task Select_Sync_IList_Count() [Fact] public async Task Select_Sync_IList_ToList() { - var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 }); + var xs = ToAsyncEnumerableIList([1, 2, 3, 4, 5]); var ys = xs.Select(x => x * 2); Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToListAsync()); @@ -275,10 +275,10 @@ public async Task Select_Sync_IList_ToList() [Fact] public async Task Select_Sync_IList_ToArray() { - var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 }); + var xs = ToAsyncEnumerableIList([1, 2, 3, 4, 5]); var ys = xs.Select(x => x * 2); - Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToArrayAsync()); + Assert.Equal([2, 4, 6, 8, 10], await ys.ToArrayAsync()); } [Fact] @@ -293,7 +293,7 @@ public void SelectAwait_Null() [Fact] public async Task SelectAwait_Simple() { - var xs = ToAsyncEnumerable(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerable([0, 1, 2]); var ys = xs.SelectAwait(x => new ValueTask((char)('a' + x))); var e = ys.GetAsyncEnumerator(); @@ -306,7 +306,7 @@ public async Task SelectAwait_Simple() [Fact] public async Task SelectAwait_Simple_IList() { - var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerableIList([0, 1, 2]); var ys = xs.SelectAwait(x => new ValueTask((char)('a' + x))); var e = ys.GetAsyncEnumerator(); @@ -332,7 +332,7 @@ public async Task SelectAwait_Simple_AsyncIterator() [Fact] public async Task SelectAwait_Indexed() { - var xs = ToAsyncEnumerable(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerable([8, 5, 7]); var ys = xs.SelectAwait((x, i) => new ValueTask((char)('a' + i))); var e = ys.GetAsyncEnumerator(); @@ -345,7 +345,7 @@ public async Task SelectAwait_Indexed() [Fact] public async Task SelectAwait_Indexed_IList() { - var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerableIList([8, 5, 7]); var ys = xs.SelectAwait((x, i) => new ValueTask((char)('a' + i))); var e = ys.GetAsyncEnumerator(); @@ -371,7 +371,7 @@ public async Task SelectAwait_Indexed_AsyncIterator() [Fact] public async Task SelectAwait_Throws_Selector() { - var xs = ToAsyncEnumerable(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerable([0, 1, 2]); var ys = xs.SelectAwait(x => new ValueTask(1 / x)); var e = ys.GetAsyncEnumerator(); @@ -381,7 +381,7 @@ public async Task SelectAwait_Throws_Selector() [Fact] public async Task SelectAwait_Throws_Selector_IList() { - var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerableIList([0, 1, 2]); var ys = xs.SelectAwait(x => new ValueTask(1 / x)); var e = ys.GetAsyncEnumerator(); @@ -401,7 +401,7 @@ public async Task SelectAwait_Throws_Selector_AsyncIterator() [Fact] public async Task SelectAwait_Indexed_Throws_Selector() { - var xs = ToAsyncEnumerable(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerable([8, 5, 7]); var ys = xs.SelectAwait((x, i) => new ValueTask(1 / i)); var e = ys.GetAsyncEnumerator(); @@ -411,7 +411,7 @@ public async Task SelectAwait_Indexed_Throws_Selector() [Fact] public async Task SelectAwait_Indexed_Throws_Selector_IList() { - var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerableIList([8, 5, 7]); var ys = xs.SelectAwait((x, i) => new ValueTask(1 / i)); var e = ys.GetAsyncEnumerator(); @@ -431,7 +431,7 @@ public async Task SelectAwait_Indexed_Throws_Selector_AsyncIterator() [Fact] public async Task SelectAwait_SelectSelect() { - var xs = ToAsyncEnumerable(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerable([0, 1, 2]); var ys = xs.SelectAwait(i => new ValueTask(i + 3)).SelectAwait(x => new ValueTask((char)('a' + x))); var e = ys.GetAsyncEnumerator(); @@ -444,7 +444,7 @@ public async Task SelectAwait_SelectSelect() [Fact] public async Task SelectAwait_SelectSelect_IList() { - var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerableIList([0, 1, 2]); var ys = xs.SelectAwait(i => new ValueTask(i + 3)).SelectAwait(x => new ValueTask((char)('a' + x))); var e = ys.GetAsyncEnumerator(); @@ -470,7 +470,7 @@ public async Task SelectAwait_SelectSelectAwaitIterator() [Fact] public async Task SelectAwait_SequenceIdentity() { - var xs = ToAsyncEnumerable(new[] { 1, 2, 3 }); + var xs = ToAsyncEnumerable([1, 2, 3]); var ys = xs.SelectAwait(x => new ValueTask((char)('a' + x))); await SequenceIdentity(ys); @@ -479,7 +479,7 @@ public async Task SelectAwait_SequenceIdentity() [Fact] public async Task SelectAwait_SequenceIdentity_IList() { - var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3 }); + var xs = ToAsyncEnumerableIList([1, 2, 3]); var ys = xs.SelectAwait(x => new ValueTask((char)('a' + x))); await SequenceIdentity(ys); @@ -497,7 +497,7 @@ public async Task SelectAwait_SequenceIdentity_AsyncIterator() [Fact] public async Task SelectAwait_Indexed_SequenceIdentity() { - var xs = ToAsyncEnumerable(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerable([8, 5, 7]); var ys = xs.SelectAwait((x, i) => new ValueTask((char)('a' + i))); await SequenceIdentity(ys); @@ -506,7 +506,7 @@ public async Task SelectAwait_Indexed_SequenceIdentity() [Fact] public async Task SelectAwait_Indexed_SequenceIdentity_IList() { - var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerableIList([8, 5, 7]); var ys = xs.SelectAwait((x, i) => new ValueTask((char)('a' + i))); await SequenceIdentity(ys); @@ -524,7 +524,7 @@ public async Task SelectAwait_Indexed_SequenceIdentity_AsyncIterator() [Fact] public async Task SelectAwait_IList_Count() { - var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 }); + var xs = ToAsyncEnumerableIList([1, 2, 3, 4, 5]); var ys = xs.SelectAwait(x => new ValueTask(x * 2)); Assert.Equal(5, await ys.CountAsync()); @@ -533,7 +533,7 @@ public async Task SelectAwait_IList_Count() [Fact] public async Task SelectAwait_IList_ToList() { - var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 }); + var xs = ToAsyncEnumerableIList([1, 2, 3, 4, 5]); var ys = xs.SelectAwait(x => new ValueTask(x * 2)); Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToListAsync()); @@ -542,10 +542,10 @@ public async Task SelectAwait_IList_ToList() [Fact] public async Task SelectAwait_IList_ToArray() { - var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 }); + var xs = ToAsyncEnumerableIList([1, 2, 3, 4, 5]); var ys = xs.SelectAwait(x => new ValueTask(x * 2)); - Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToArrayAsync()); + Assert.Equal([2, 4, 6, 8, 10], await ys.ToArrayAsync()); } #if !NO_DEEP_CANCELLATION @@ -562,7 +562,7 @@ public void SelectAwaitWithCancellation_Null() [Fact] public async Task SelectAwaitWithCancellation_Simple() { - var xs = ToAsyncEnumerable(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerable([0, 1, 2]); var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask((char)('a' + x))); var e = ys.GetAsyncEnumerator(); @@ -575,7 +575,7 @@ public async Task SelectAwaitWithCancellation_Simple() [Fact] public async Task SelectAwaitWithCancellation_Simple_IList() { - var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerableIList([0, 1, 2]); var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask((char)('a' + x))); var e = ys.GetAsyncEnumerator(); @@ -601,7 +601,7 @@ public async Task SelectAwaitWithCancellation_Simple_Async_CancelIterator() [Fact] public async Task SelectAwaitWithCancellation_Indexed() { - var xs = ToAsyncEnumerable(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerable([8, 5, 7]); var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask((char)('a' + i))); var e = ys.GetAsyncEnumerator(); @@ -614,7 +614,7 @@ public async Task SelectAwaitWithCancellation_Indexed() [Fact] public async Task SelectAwaitWithCancellation_Indexed_IList() { - var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerableIList([8, 5, 7]); var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask((char)('a' + i))); var e = ys.GetAsyncEnumerator(); @@ -640,7 +640,7 @@ public async Task SelectAwaitWithCancellation_Indexed_Async_CancelIterator() [Fact] public async Task SelectAwaitWithCancellation_Throws_Selector() { - var xs = ToAsyncEnumerable(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerable([0, 1, 2]); var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask(1 / x)); var e = ys.GetAsyncEnumerator(); @@ -650,7 +650,7 @@ public async Task SelectAwaitWithCancellation_Throws_Selector() [Fact] public async Task SelectAwaitWithCancellation_Throws_Selector_IList() { - var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerableIList([0, 1, 2]); var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask(1 / x)); var e = ys.GetAsyncEnumerator(); @@ -670,7 +670,7 @@ public async Task SelectAwaitWithCancellation_Throws_Selector_Async_CancelIterat [Fact] public async Task SelectAwaitWithCancellation_Indexed_Throws_Selector() { - var xs = ToAsyncEnumerable(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerable([8, 5, 7]); var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask(1 / i)); var e = ys.GetAsyncEnumerator(); @@ -680,7 +680,7 @@ public async Task SelectAwaitWithCancellation_Indexed_Throws_Selector() [Fact] public async Task SelectAwaitWithCancellation_Indexed_Throws_Selector_IList() { - var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerableIList([8, 5, 7]); var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask(1 / i)); var e = ys.GetAsyncEnumerator(); @@ -700,7 +700,7 @@ public async Task SelectAwaitWithCancellation_Indexed_Throws_Selector_Async_Canc [Fact] public async Task SelectAwaitWithCancellation_SelectSelect() { - var xs = ToAsyncEnumerable(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerable([0, 1, 2]); var ys = xs.SelectAwaitWithCancellation((int i, CancellationToken ct) => new ValueTask(i + 3)).SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask((char)('a' + x))); var e = ys.GetAsyncEnumerator(); @@ -713,7 +713,7 @@ public async Task SelectAwaitWithCancellation_SelectSelect() [Fact] public async Task SelectAwaitWithCancellation_SelectSelect_IList() { - var xs = ToAsyncEnumerableIList(new[] { 0, 1, 2 }); + var xs = ToAsyncEnumerableIList([0, 1, 2]); var ys = xs.SelectAwaitWithCancellation((int i, CancellationToken ct) => new ValueTask(i + 3)).SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask((char)('a' + x))); var e = ys.GetAsyncEnumerator(); @@ -739,7 +739,7 @@ public async Task SelectAwaitWithCancellation_SelectSelectAwait_CancelIterator() [Fact] public async Task SelectAwaitWithCancellation_SequenceIdentity() { - var xs = ToAsyncEnumerable(new[] { 1, 2, 3 }); + var xs = ToAsyncEnumerable([1, 2, 3]); var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask((char)('a' + x))); await SequenceIdentity(ys); @@ -748,7 +748,7 @@ public async Task SelectAwaitWithCancellation_SequenceIdentity() [Fact] public async Task SelectAwaitWithCancellation_SequenceIdentity_IList() { - var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3 }); + var xs = ToAsyncEnumerableIList([1, 2, 3]); var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask((char)('a' + x))); await SequenceIdentity(ys); @@ -766,7 +766,7 @@ public async Task SelectAwaitWithCancellation_SequenceIdentity_Async_CancelItera [Fact] public async Task SelectAwaitWithCancellation_Indexed_SequenceIdentity() { - var xs = ToAsyncEnumerable(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerable([8, 5, 7]); var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask((char)('a' + i))); await SequenceIdentity(ys); @@ -775,7 +775,7 @@ public async Task SelectAwaitWithCancellation_Indexed_SequenceIdentity() [Fact] public async Task SelectAwaitWithCancellation_Indexed_SequenceIdentity_IList() { - var xs = ToAsyncEnumerableIList(new[] { 8, 5, 7 }); + var xs = ToAsyncEnumerableIList([8, 5, 7]); var ys = xs.SelectAwaitWithCancellation((x, i, ct) => new ValueTask((char)('a' + i))); await SequenceIdentity(ys); @@ -793,7 +793,7 @@ public async Task SelectAwaitWithCancellation_Indexed_SequenceIdentity_Async_Can [Fact] public async Task SelectAwaitWithCancellation_IList_Count() { - var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 }); + var xs = ToAsyncEnumerableIList([1, 2, 3, 4, 5]); var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask(x * 2)); Assert.Equal(5, await ys.CountAsync()); @@ -802,7 +802,7 @@ public async Task SelectAwaitWithCancellation_IList_Count() [Fact] public async Task SelectAwaitWithCancellation_IList_ToList() { - var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 }); + var xs = ToAsyncEnumerableIList([1, 2, 3, 4, 5]); var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask(x * 2)); Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToListAsync()); @@ -811,15 +811,21 @@ public async Task SelectAwaitWithCancellation_IList_ToList() [Fact] public async Task SelectAwaitWithCancellation_IList_ToArray() { - var xs = ToAsyncEnumerableIList(new[] { 1, 2, 3, 4, 5 }); + var xs = ToAsyncEnumerableIList([1, 2, 3, 4, 5]); var ys = xs.SelectAwaitWithCancellation((int x, CancellationToken ct) => new ValueTask(x * 2)); - Assert.Equal(new[] { 2, 4, 6, 8, 10 }, await ys.ToArrayAsync()); + Assert.Equal([2, 4, 6, 8, 10], await ys.ToArrayAsync()); } #endif +#if NET8_0_OR_GREATER +#pragma warning disable CA1859 // Use specific iterator type for perf. Not really necessary for tests. +#endif private static IAsyncEnumerable ToAsyncEnumerable(int[] xs) => new MyIterator(xs); +#if NET8_0_OR_GREATER +#pragma warning restore CA1859 +#endif private class MyIterator : IAsyncEnumerable { @@ -838,13 +844,19 @@ private class Enumerator : IAsyncEnumerator public int Current => _parent._xs[_i]; - public ValueTask DisposeAsync() => new ValueTask(); + public ValueTask DisposeAsync() => new(); - public ValueTask MoveNextAsync() => new ValueTask(++_i < _parent._xs.Length); + public ValueTask MoveNextAsync() => new(++_i < _parent._xs.Length); } } +#if NET8_0_OR_GREATER +#pragma warning disable CA1859 // Use specific iterator type for perf. Not really necessary for tests. +#endif private static IAsyncEnumerable ToAsyncEnumerableIList(int[] xs) => new MyIteratorIList(xs); +#if NET8_0_OR_GREATER +#pragma warning restore CA1859 +#endif private class MyIteratorIList : IAsyncEnumerable, IList { @@ -889,9 +901,9 @@ private class Enumerator : IAsyncEnumerator public int Current => _parent._xs[_i]; - public ValueTask DisposeAsync() => new ValueTask(); + public ValueTask DisposeAsync() => new(); - public ValueTask MoveNextAsync() => new ValueTask(++_i < _parent._xs.Length); + public ValueTask MoveNextAsync() => new(++_i < _parent._xs.Length); } } } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Single.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Single.cs index 35890d8db4..83dad5c1ca 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Single.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Single.cs @@ -29,7 +29,7 @@ public async Task SingleAsync_Empty() [Fact] public async Task SingleAsync_Empty_IList() { - var res = new int[0].ToAsyncEnumerable().SingleAsync(); + var res = Array.Empty().ToAsyncEnumerable().SingleAsync(); await AssertThrowsAsync(res.AsTask()); } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/SingleOrDefault.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/SingleOrDefault.cs index 7b6137ab6c..21e3e478e8 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/SingleOrDefault.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/SingleOrDefault.cs @@ -29,7 +29,7 @@ public async Task SingleOrDefaultAsync_Empty() [Fact] public async Task SingleOrDefaultAsync_Empty_IList() { - var res = new int[0].ToAsyncEnumerable().SingleOrDefaultAsync(); + var res = Array.Empty().ToAsyncEnumerable().SingleOrDefaultAsync(); Assert.Equal(0, await res); } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Skip.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Skip.cs index 25d7635d3f..3a358fa074 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Skip.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Skip.cs @@ -123,7 +123,7 @@ public async Task Skip_IAsyncPartition_NonEmpty_Skip() Assert.Equal(3, await ys.ElementAtAsync(0)); Assert.Equal(4, await ys.ElementAtAsync(1)); - Assert.Equal(new[] { 3, 4 }, await ys.ToArrayAsync()); + Assert.Equal([3, 4], await ys.ToArrayAsync()); Assert.Equal(new[] { 3, 4 }, await ys.ToListAsync()); } @@ -141,7 +141,7 @@ public async Task Skip_IAsyncPartition_NonEmpty_SkipSkip() Assert.Equal(3, await ys.ElementAtAsync(0)); Assert.Equal(4, await ys.ElementAtAsync(1)); - Assert.Equal(new[] { 3, 4 }, await ys.ToArrayAsync()); + Assert.Equal([3, 4], await ys.ToArrayAsync()); Assert.Equal(new[] { 3, 4 }, await ys.ToListAsync()); } @@ -159,14 +159,14 @@ public async Task Skip_IAsyncPartition_NonEmpty_SkipTake() Assert.Equal(3, await ys.ElementAtAsync(0)); Assert.Equal(4, await ys.ElementAtAsync(1)); - Assert.Equal(new[] { 3, 4 }, await ys.ToArrayAsync()); + Assert.Equal([3, 4], await ys.ToArrayAsync()); Assert.Equal(new[] { 3, 4 }, await ys.ToListAsync()); } [Fact] public async Task Skip_IAsyncPartition_Empty_Skip() { - var xs = new int[0].ToAsyncEnumerable().Where(x => true); + var xs = Array.Empty().ToAsyncEnumerable().Where(x => true); var ys = xs.Skip(2); Assert.Equal(0, await ys.CountAsync()); @@ -213,7 +213,7 @@ public async Task Skip_IAsyncPartition_IList_NonEmpty_Skip() Assert.Equal(3, await ys.ElementAtAsync(0)); Assert.Equal(4, await ys.ElementAtAsync(1)); - Assert.Equal(new[] { 3, 4 }, await ys.ToArrayAsync()); + Assert.Equal([3, 4], await ys.ToArrayAsync()); Assert.Equal(new[] { 3, 4 }, await ys.ToListAsync()); } @@ -231,7 +231,7 @@ public async Task Skip_IAsyncPartition_IList_NonEmpty_SkipSkip() Assert.Equal(3, await ys.ElementAtAsync(0)); Assert.Equal(4, await ys.ElementAtAsync(1)); - Assert.Equal(new[] { 3, 4 }, await ys.ToArrayAsync()); + Assert.Equal([3, 4], await ys.ToArrayAsync()); Assert.Equal(new[] { 3, 4 }, await ys.ToListAsync()); } @@ -249,14 +249,14 @@ public async Task Skip_IAsyncPartition_IList_NonEmpty_SkipTake() Assert.Equal(3, await ys.ElementAtAsync(0)); Assert.Equal(4, await ys.ElementAtAsync(1)); - Assert.Equal(new[] { 3, 4 }, await ys.ToArrayAsync()); + Assert.Equal([3, 4], await ys.ToArrayAsync()); Assert.Equal(new[] { 3, 4 }, await ys.ToListAsync()); } [Fact] public async Task Skip_IAsyncPartition_IList_Empty_Skip() { - var xs = new int[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); var ys = xs.Skip(2); Assert.Equal(0, await ys.CountAsync()); diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Take.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Take.cs index b200650f81..451fbcece0 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Take.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Take.cs @@ -143,7 +143,7 @@ public async Task Take_IAsyncPartition_NonEmpty_Take() Assert.Equal(1, await ys.ElementAtAsync(0)); Assert.Equal(2, await ys.ElementAtAsync(1)); - Assert.Equal(new[] { 1, 2 }, await ys.ToArrayAsync()); + Assert.Equal([1, 2], await ys.ToArrayAsync()); Assert.Equal(new[] { 1, 2 }, await ys.ToListAsync()); } @@ -161,7 +161,7 @@ public async Task Take_IAsyncPartition_NonEmpty_TakeTake() Assert.Equal(1, await ys.ElementAtAsync(0)); Assert.Equal(2, await ys.ElementAtAsync(1)); - Assert.Equal(new[] { 1, 2 }, await ys.ToArrayAsync()); + Assert.Equal([1, 2], await ys.ToArrayAsync()); Assert.Equal(new[] { 1, 2 }, await ys.ToListAsync()); } @@ -179,14 +179,14 @@ public async Task Take_IAsyncPartition_NonEmpty_TakeSkip() Assert.Equal(3, await ys.ElementAtAsync(0)); Assert.Equal(4, await ys.ElementAtAsync(1)); - Assert.Equal(new[] { 3, 4 }, await ys.ToArrayAsync()); + Assert.Equal([3, 4], await ys.ToArrayAsync()); Assert.Equal(new[] { 3, 4 }, await ys.ToListAsync()); } [Fact] public async Task Take_IAsyncPartition_Empty_Take() { - var xs = new int[0].ToAsyncEnumerable().Where(x => true); + var xs = Array.Empty().ToAsyncEnumerable().Where(x => true); var ys = xs.Take(2); Assert.Equal(0, await ys.CountAsync()); @@ -233,7 +233,7 @@ public async Task Take_IAsyncPartition_IList_NonEmpty_Take() Assert.Equal(1, await ys.ElementAtAsync(0)); Assert.Equal(2, await ys.ElementAtAsync(1)); - Assert.Equal(new[] { 1, 2 }, await ys.ToArrayAsync()); + Assert.Equal([1, 2], await ys.ToArrayAsync()); Assert.Equal(new[] { 1, 2 }, await ys.ToListAsync()); } @@ -251,7 +251,7 @@ public async Task Take_IAsyncPartition_IList_NonEmpty_TakeTake() Assert.Equal(1, await ys.ElementAtAsync(0)); Assert.Equal(2, await ys.ElementAtAsync(1)); - Assert.Equal(new[] { 1, 2 }, await ys.ToArrayAsync()); + Assert.Equal([1, 2], await ys.ToArrayAsync()); Assert.Equal(new[] { 1, 2 }, await ys.ToListAsync()); } @@ -269,14 +269,14 @@ public async Task Take_IAsyncPartition_IList_NonEmpty_TakeSkip() Assert.Equal(3, await ys.ElementAtAsync(0)); Assert.Equal(4, await ys.ElementAtAsync(1)); - Assert.Equal(new[] { 3, 4 }, await ys.ToArrayAsync()); + Assert.Equal([3, 4], await ys.ToArrayAsync()); Assert.Equal(new[] { 3, 4 }, await ys.ToListAsync()); } [Fact] public async Task Take_IAsyncPartition_IList_Empty_Take() { - var xs = new int[0].ToAsyncEnumerable(); + var xs = Array.Empty().ToAsyncEnumerable(); var ys = xs.Take(2); Assert.Equal(0, await ys.CountAsync()); diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToArray.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToArray.cs index 6548f741ea..98b1cb66d5 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToArray.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToArray.cs @@ -31,7 +31,7 @@ public async Task ToArray_IAsyncIListProvider_Simple() [Fact] public async Task ToArray_IAsyncIListProvider_Empty1() { - var xs = new int[0]; + var xs = Array.Empty(); var res = xs.ToAsyncEnumerable().ToArrayAsync(); Assert.True((await res).SequenceEqual(xs)); } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToAsyncEnumerable.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToAsyncEnumerable.cs index d9cf28ef97..30afcbb78e 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToAsyncEnumerable.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToAsyncEnumerable.cs @@ -113,7 +113,7 @@ private IEnumerable ToAsyncEnumerable_Sequence_Throw(Exception e) [Fact] public async Task ToAsyncEnumerable_Enumerable_HashSet() { - var set = new HashSet(new[] { 1, 2, 3, 4 }); + var set = new HashSet([1, 2, 3, 4]); var xs = set.ToAsyncEnumerable(); var e = xs.GetAsyncEnumerator(); @@ -127,7 +127,7 @@ public async Task ToAsyncEnumerable_Enumerable_HashSet() [Fact] public async Task ToAsyncEnumerable_Enumerable_HashSet_ToArray() { - var set = new HashSet(new[] { 1, 2, 3, 4, 5, 6, 7, 8 }); + var set = new HashSet([1, 2, 3, 4, 5, 6, 7, 8]); var xs = set.ToAsyncEnumerable(); @@ -139,7 +139,7 @@ public async Task ToAsyncEnumerable_Enumerable_HashSet_ToArray() [Fact] public async Task ToAsyncEnumerable_Enumerable_HashSet_ToList() { - var set = new HashSet(new[] { 1, 2, 3, 4 }); + var set = new HashSet([1, 2, 3, 4]); var xs = set.ToAsyncEnumerable(); var arr = await xs.ToListAsync(); @@ -150,7 +150,7 @@ public async Task ToAsyncEnumerable_Enumerable_HashSet_ToList() [Fact] public async Task ToAsyncEnumerable_Enumerable_HashSet_Count() { - var set = new HashSet(new[] { 1, 2, 3, 4 }); + var set = new HashSet([1, 2, 3, 4]); var xs = set.ToAsyncEnumerable(); var c = await xs.CountAsync(); @@ -161,7 +161,7 @@ public async Task ToAsyncEnumerable_Enumerable_HashSet_Count() [Fact] public async Task ToAsyncEnumerable_Enumerable_HashSet_SequenceIdentity() { - var set = new HashSet(new[] { 1, 2, 3, 4 }); + var set = new HashSet([1, 2, 3, 4]); var xs = set.ToAsyncEnumerable(); await SequenceIdentity(xs); @@ -170,7 +170,7 @@ public async Task ToAsyncEnumerable_Enumerable_HashSet_SequenceIdentity() [Fact] public void ToAsyncEnumerable_Enumerable_HashSet_ICollection() { - var set = new HashSet(new[] { 1, 2, 3, 4 }); + var set = new HashSet([1, 2, 3, 4]); var xs = set.ToAsyncEnumerable(); var xc = xs as ICollection; diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToEnumerable.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToEnumerable.cs index fc985aa89f..8abedc3d9d 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToEnumerable.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToEnumerable.cs @@ -22,14 +22,14 @@ public void ToEnumerable_Null() public void ToEnumerable_Single() { var xs = Return42.ToEnumerable(); - Assert.True(xs.SequenceEqual(new[] { 42 })); + Assert.True(xs.SequenceEqual([42])); } [Fact] public void ToEnumerable_Empty() { var xs = AsyncEnumerable.Empty().ToEnumerable(); - Assert.True(xs.SequenceEqual(new int[0])); + Assert.True(xs.SequenceEqual([])); } [Fact] diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToHashSet.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToHashSet.cs index 717e658c5d..c0cb46508d 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToHashSet.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToHashSet.cs @@ -27,7 +27,7 @@ public async Task ToHashSet_Simple() { var xs = new[] { 1, 2, 1, 2, 3, 4, 1, 2, 3, 4 }; var res = xs.ToAsyncEnumerable().ToHashSetAsync(); - Assert.True((await res).OrderBy(x => x).SequenceEqual(new[] { 1, 2, 3, 4 })); + Assert.True((await res).OrderBy(x => x).SequenceEqual([1, 2, 3, 4])); } [Fact] @@ -35,7 +35,7 @@ public async Task ToHashSet_Comparer() { var xs = new[] { 1, 12, 11, 2, 3, 14, 1, 12, 13, 4 }; var res = xs.ToAsyncEnumerable().ToHashSetAsync(new Eq()); - Assert.True((await res).OrderBy(x => x).SequenceEqual(new[] { 1, 3, 12, 14 })); + Assert.True((await res).OrderBy(x => x).SequenceEqual([1, 3, 12, 14])); } private class Eq : IEqualityComparer diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToLookup.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToLookup.cs index 03ddb74f44..08b81016b2 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToLookup.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToLookup.cs @@ -135,13 +135,11 @@ public async Task ToLookup8Async() { var xs = new[] { 1, 4, 2 }.ToAsyncEnumerable(); var res = await xs.ToLookupAsync(x => x % 2); -#pragma warning disable IDE0007 // Use implicit type foreach (IGrouping? g in (IEnumerable)res) { Assert.NotNull(g); Assert.True(g!.Key == 0 || g!.Key == 1); } -#pragma warning restore IDE0007 // Use implicit type } [Fact] diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToObservable.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToObservable.cs index 447189fd5d..fa7677ee99 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToObservable.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/ToObservable.cs @@ -74,7 +74,7 @@ public void ToObservable2() evt.WaitOne(); Assert.False(fail); - Assert.True(lst.SequenceEqual(new[] { 42 })); + Assert.True(lst.SequenceEqual([42])); } [Fact] @@ -351,7 +351,7 @@ public MyObserver(Action onNext, Action onError, Action onComplete private sealed class ThrowOnCurrentAsyncEnumerator : IAsyncEnumerator { - readonly private Exception _exception; + private readonly Exception _exception; public ThrowOnCurrentAsyncEnumerator(Exception ex) { _exception = ex; @@ -359,7 +359,7 @@ public ThrowOnCurrentAsyncEnumerator(Exception ex) public int Current => throw _exception; public ValueTask DisposeAsync() => default; - public ValueTask MoveNextAsync() => new ValueTask(true); + public ValueTask MoveNextAsync() => new(true); } } } diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Union.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Union.cs index 3f4c0a9f73..4399e5168c 100644 --- a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Union.cs +++ b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/Operators/Union.cs @@ -150,7 +150,7 @@ public async Task Union_ToArray() var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable(); var res = xs.Union(ys); - Assert.Equal(new[] { 1, 2, 3, 4, 5 }, (await res.ToArrayAsync()).OrderBy(x => x)); + Assert.Equal([1, 2, 3, 4, 5], (await res.ToArrayAsync()).OrderBy(x => x)); } [Fact] @@ -160,7 +160,7 @@ public async Task Union_ToList() var ys = new[] { 3, 5, 1, 4 }.ToAsyncEnumerable(); var res = xs.Union(ys); - Assert.Equal(new[] { 1, 2, 3, 4, 5 }, (await res.ToListAsync()).OrderBy(x => x)); + Assert.Equal([1, 2, 3, 4, 5], (await res.ToListAsync()).OrderBy(x => x)); } @@ -309,7 +309,7 @@ public DisposalDetectingEnumerable(int start, int count) _count = count; } - public List Enumerators { get; } = new List(); + public List Enumerators { get; } = []; public IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken = default) { @@ -318,7 +318,7 @@ public IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationTo return r; } - public class Enumerator : IAsyncEnumerator + public sealed class Enumerator : IAsyncEnumerator { private readonly int _max; diff --git a/Ix.NET/Source/System.Linq.Async.slnf b/Ix.NET/Source/System.Linq.Async.slnf index e3f05146b0..d250bf5447 100644 --- a/Ix.NET/Source/System.Linq.Async.slnf +++ b/Ix.NET/Source/System.Linq.Async.slnf @@ -5,7 +5,7 @@ "System.Linq.Async\\System.Linq.Async.csproj", "System.Linq.Async.Tests\\System.Linq.Async.Tests.csproj", "System.Linq.Async.SourceGenerator\\System.Linq.Async.SourceGenerator.csproj", - "refs\\System.Linq.Async.Ref\\System.Linq.Async.Ref.csproj" + "refs\\System.Linq.Async\\System.Linq.Async.csproj" ] } } diff --git a/Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj b/Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj index d09589ba79..8c7df9bd25 100644 --- a/Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj +++ b/Ix.NET/Source/System.Linq.Async/System.Linq.Async.csproj @@ -1,4 +1,4 @@ - + net48;netstandard2.0;netstandard2.1;net6.0 @@ -7,6 +7,37 @@ Provides support for Language-Integrated Query (LINQ) over IAsyncEnumerable<T> sequences. + + + + + + + + + + $(NoWarn);NU5128;NU5131 + + + + + $(NoWarn);IDE0301;IDE0305 + + True @@ -27,7 +58,6 @@ - diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerableHelpers.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerableHelpers.cs index 24e6e5c273..269c742c4c 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerableHelpers.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerableHelpers.cs @@ -93,11 +93,7 @@ internal static async ValueTask> ToArrayWithLength(IAsyncE } result.Length = 0; -#if NO_ARRAY_EMPTY - result.Array = EmptyArray.Value; -#else - result.Array = Array.Empty(); -#endif + result.Array = []; return result; } diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerablePartition.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerablePartition.cs index d0b5736df4..9e84bd79a5 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerablePartition.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncEnumerablePartition.cs @@ -25,7 +25,7 @@ internal sealed class AsyncEnumerablePartition : AsyncIterator internal AsyncEnumerablePartition(IAsyncEnumerable source, int minIndexInclusive, int maxIndexInclusive) { - Debug.Assert(!(source is IList), $"The caller needs to check for {nameof(IList)}."); + Debug.Assert(source is not IList, $"The caller needs to check for {nameof(IList)}."); Debug.Assert(minIndexInclusive >= 0); Debug.Assert(maxIndexInclusive >= -1); // Note that although maxIndexInclusive can't grow, it can still be int.MaxValue. @@ -303,7 +303,7 @@ public async ValueTask ToArrayAsync(CancellationToken cancellationTok // REVIEW: If this ends up in corefx, the code below can use LargeArrayBuilder. - var builder = HasLimit ? new List(Limit) : new List(); + var builder = HasLimit ? new List(Limit) : []; do { @@ -320,11 +320,7 @@ public async ValueTask ToArrayAsync(CancellationToken cancellationTok await en.DisposeAsync().ConfigureAwait(false); } -#if NO_ARRAY_EMPTY - return EmptyArray.Value; -#else - return Array.Empty(); -#endif + return []; } public async ValueTask> ToListAsync(CancellationToken cancellationToken) diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncListPartition.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncListPartition.cs index 08ce7921cb..0ab5e91491 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncListPartition.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/AsyncListPartition.cs @@ -147,13 +147,7 @@ public ValueTask ToArrayAsync(CancellationToken cancellationToken) var count = Count; if (count == 0) { - return new ValueTask( -#if NO_ARRAY_EMPTY - EmptyArray.Value -#else - Array.Empty() -#endif - ); + return new ValueTask([]); } var array = new TSource[count]; @@ -170,7 +164,7 @@ public ValueTask> ToListAsync(CancellationToken cancellationToken) var count = Count; if (count == 0) { - return new ValueTask>(new List()); + return new ValueTask>([]); } var list = new List(count); diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Disposables.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Disposables.cs index 8fccaed589..1f5e31c3c4 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Disposables.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Disposables.cs @@ -8,7 +8,7 @@ namespace System.Linq { internal sealed class CancellationTokenDisposable : IDisposable { - private readonly CancellationTokenSource _cts = new CancellationTokenSource(); + private readonly CancellationTokenSource _cts = new(); public CancellationToken Token => _cts.Token; diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AppendPrepend.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AppendPrepend.cs index 148edf9c0f..8b146d68c4 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AppendPrepend.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/AppendPrepend.cs @@ -241,7 +241,7 @@ public override async ValueTask> ToListAsync(CancellationToken can cancellationToken.ThrowIfCancellationRequested(); - var list = count == -1 ? new List() : new List(count); + var list = count == -1 ? [] : new List(count); if (!_appending) { @@ -429,7 +429,7 @@ public override async ValueTask ToArrayAsync(CancellationToken cancel public override async ValueTask> ToListAsync(CancellationToken cancellationToken) { var count = await GetCountAsync(onlyIfCheap: true, cancellationToken).ConfigureAwait(false); - var list = count == -1 ? new List() : new List(count); + var list = count == -1 ? [] : new List(count); for (var n = _prepended; n != null; n = n.Linked) { list.Add(n.Item); diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/DefaultIfEmpty.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/DefaultIfEmpty.cs index 0879ad6611..8fe637ffa5 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/DefaultIfEmpty.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/DefaultIfEmpty.cs @@ -103,7 +103,7 @@ protected override async ValueTask MoveNextCore() public async ValueTask ToArrayAsync(CancellationToken cancellationToken) { var array = await _source.ToArrayAsync(cancellationToken).ConfigureAwait(false); - return array.Length == 0 ? new[] { _defaultValue } : array; + return array.Length == 0 ? [_defaultValue] : array; } public async ValueTask> ToListAsync(CancellationToken cancellationToken) diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Empty.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Empty.cs index 0b93e6864a..7509ef4dc5 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Empty.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Empty.cs @@ -19,33 +19,27 @@ public static partial class AsyncEnumerable internal sealed class EmptyAsyncIterator : IAsyncPartition, IAsyncEnumerator { - public static readonly EmptyAsyncIterator Instance = new EmptyAsyncIterator(); + public static readonly EmptyAsyncIterator Instance = new(); public TValue Current => default!; - public ValueTask GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new ValueTask(0); + public ValueTask GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new(0); public IAsyncPartition Skip(int count) => this; public IAsyncPartition Take(int count) => this; - public ValueTask ToArrayAsync(CancellationToken cancellationToken) => new ValueTask( -#if NO_ARRAY_EMPTY - EmptyArray.Value -#else - Array.Empty() -#endif - ); + public ValueTask ToArrayAsync(CancellationToken cancellationToken) => new([]); - public ValueTask> ToListAsync(CancellationToken cancellationToken) => new ValueTask>(new List()); + public ValueTask> ToListAsync(CancellationToken cancellationToken) => new([]); - public ValueTask> TryGetElementAtAsync(int index, CancellationToken cancellationToken) => new ValueTask>(new Maybe()); + public ValueTask> TryGetElementAtAsync(int index, CancellationToken cancellationToken) => new(new Maybe()); - public ValueTask> TryGetFirstAsync(CancellationToken cancellationToken) => new ValueTask>(new Maybe()); + public ValueTask> TryGetFirstAsync(CancellationToken cancellationToken) => new(new Maybe()); - public ValueTask> TryGetLastAsync(CancellationToken cancellationToken) => new ValueTask>(new Maybe()); + public ValueTask> TryGetLastAsync(CancellationToken cancellationToken) => new(new Maybe()); - public ValueTask MoveNextAsync() => new ValueTask(false); + public ValueTask MoveNextAsync() => new(false); public IAsyncEnumerator GetAsyncEnumerator(CancellationToken cancellationToken) { diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Grouping.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Grouping.cs index b042b48fe7..218bbb764c 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Grouping.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Grouping.cs @@ -14,12 +14,14 @@ namespace System.Linq.Internal /// Source: https://github.com/dotnet/corefx/blob/b90532bc97b07234a7d18073819d019645285f1c/src/System.Linq/src/System/Linq/Grouping.cs#L64 internal class Grouping : IGrouping, IList, IAsyncGrouping { +#pragma warning disable IDE1006 // Naming Styles internal int _count; internal TElement[] _elements; internal int _hashCode; internal Grouping _hashNext; internal TKey _key; internal Grouping? _next; +#pragma warning restore IDE1006 // Naming Styles public Grouping(TKey key, int hashCode, TElement[] elements, Grouping hashNext) { diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs index 57466df571..854f1583df 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Lookup.cs @@ -35,11 +35,7 @@ public IEnumerable this[TKey key] return grouping; } -#if NO_ARRAY_EMPTY - return EmptyArray.Value; -#else return Array.Empty(); -#endif } } @@ -317,11 +313,7 @@ public IEnumerable this[TKey key] return grouping; } -#if NO_ARRAY_EMPTY - return EmptyArray.Value; -#else return Array.Empty(); -#endif } } diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderedAsyncEnumerable.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderedAsyncEnumerable.cs index 02d5377a0e..54df9aa8fc 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderedAsyncEnumerable.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/OrderedAsyncEnumerable.cs @@ -87,11 +87,7 @@ public async ValueTask ToArrayAsync(CancellationToken cancellationTo if (count == 0) { -#if NO_ARRAY_EMPTY - return EmptyArray.Value; -#else - return Array.Empty(); -#endif + return []; } var array = elements.Array; @@ -116,11 +112,7 @@ internal async ValueTask ToArrayAsync(int minIndexInclusive, int max if (count <= minIndexInclusive) { -#if NO_ARRAY_EMPTY - return EmptyArray.Value; -#else - return Array.Empty(); -#endif + return []; } if (count <= maxIndexInclusive) @@ -136,7 +128,7 @@ internal async ValueTask ToArrayAsync(int minIndexInclusive, int max var element = await sorter.ElementAt(array, count, minIndexInclusive).ConfigureAwait(false); - return new TElement[] { element }; + return [element]; } var map = await SortedMap(array, count, minIndexInclusive, maxIndexInclusive, cancellationToken).ConfigureAwait(false); @@ -159,7 +151,7 @@ public async ValueTask> ToListAsync(CancellationToken cancellatio if (count == 0) { - return new List(capacity: 0); + return []; } var array = elements.Array; @@ -184,7 +176,7 @@ internal async ValueTask> ToListAsync(int minIndexInclusive, int if (count <= minIndexInclusive) { - return new List(0); + return []; } if (count <= maxIndexInclusive) @@ -200,7 +192,7 @@ internal async ValueTask> ToListAsync(int minIndexInclusive, int var element = await sorter.ElementAt(array, count, minIndexInclusive).ConfigureAwait(false); - return new List(1) { element }; + return [element]; } var map = await SortedMap(array, count, minIndexInclusive, maxIndexInclusive, cancellationToken).ConfigureAwait(false); @@ -651,9 +643,7 @@ protected override void PartialQuickSort(int[] map, int left, int right, int min if (i < j) { - var temp = map[i]; - map[i] = map[j]; - map[j] = temp; + (map[j], map[i]) = (map[i], map[j]); } i++; @@ -720,9 +710,7 @@ protected override int QuickSelect(int[] map, int right, int idx) if (i < j) { - var temp = map[i]; - map[i] = map[j]; - map[j] = temp; + (map[j], map[i]) = (map[i], map[j]); } i++; diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Range.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Range.cs index dcfe20372e..013a1b00a3 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Range.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Range.cs @@ -48,7 +48,7 @@ public RangeAsyncIterator(int start, int count) public override AsyncIteratorBase Clone() => new RangeAsyncIterator(_start, _end - _start); - public ValueTask GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new ValueTask(_end - _start); + public ValueTask GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new(_end - _start); public IAsyncPartition Skip(int count) { @@ -110,9 +110,9 @@ public ValueTask> TryGetElementAtAsync(int index, CancellationToken c return new ValueTask>(new Maybe()); } - public ValueTask> TryGetFirstAsync(CancellationToken cancellationToken) => new ValueTask>(new Maybe(_start)); + public ValueTask> TryGetFirstAsync(CancellationToken cancellationToken) => new(new Maybe(_start)); - public ValueTask> TryGetLastAsync(CancellationToken cancellationToken) => new ValueTask>(new Maybe(_end - 1)); + public ValueTask> TryGetLastAsync(CancellationToken cancellationToken) => new(new Maybe(_end - 1)); protected override ValueTask MoveNextCore() { diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Repeat.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Repeat.cs index ed4a7f967e..b89feb64cf 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Repeat.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Repeat.cs @@ -40,7 +40,7 @@ public RepeatAsyncIterator(TResult element, int count) public override AsyncIteratorBase Clone() => new RepeatAsyncIterator(_element, _count); - public ValueTask GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new ValueTask(_count); + public ValueTask GetCountAsync(bool onlyIfCheap, CancellationToken cancellationToken) => new(_count); public ValueTask ToArrayAsync(CancellationToken cancellationToken) { diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Reverse.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Reverse.cs index 72c7d9e707..13f314d239 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Reverse.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Reverse.cs @@ -46,9 +46,7 @@ public async ValueTask ToArrayAsync(CancellationToken cancellationTok // checking that has its own cost, so just use this approach for all types. for (int i = 0, j = array.Length - 1; i < j; ++i, --j) { - var temp = array[i]; - array[i] = array[j]; - array[j] = temp; + (array[j], array[i]) = (array[i], array[j]); } return array; @@ -71,7 +69,7 @@ public ValueTask GetCountAsync(bool onlyIfCheap, CancellationToken cancella return listProv.GetCountAsync(true, cancellationToken); } - if (!(_source is ICollection) && !(_source is ICollection)) + if (_source is not ICollection && _source is not ICollection) { return new ValueTask(-1); } diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SingleLinkedNode.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SingleLinkedNode.cs index dc7478eecb..5c36539a64 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SingleLinkedNode.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SingleLinkedNode.cs @@ -50,7 +50,7 @@ private SingleLinkedNode(SingleLinkedNode linked, TSource item) /// Creates a new node that holds the specified item and is linked to this node. /// /// The item to place in the new node. - public SingleLinkedNode Add(TSource item) => new SingleLinkedNode(this, item); + public SingleLinkedNode Add(TSource item) => new(this, item); /// /// Gets the number of items in this and subsequent nodes by walking the linked list. diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.Observable.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.Observable.cs index 6fa01ebba3..700401e815 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.Observable.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToAsyncEnumerable.Observable.cs @@ -30,7 +30,7 @@ private sealed class ObservableAsyncEnumerable : AsyncIterator { private readonly IObservable _source; - private ConcurrentQueue? _values = new ConcurrentQueue(); + private ConcurrentQueue? _values = new(); private Exception? _error; private bool _completed; private TaskCompletionSource? _signal; diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToObservable.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToObservable.cs index 89d9bbc3c6..0e60ff0456 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToObservable.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/ToObservable.cs @@ -38,41 +38,39 @@ public IDisposable Subscribe(IObserver observer) async void Core() { - await using (var e = _source.GetAsyncEnumerator(ctd.Token)) + await using var e = _source.GetAsyncEnumerator(ctd.Token); + do { - do - { - bool hasNext; - var value = default(T)!; + bool hasNext; + var value = default(T)!; - try + try + { + hasNext = await e.MoveNextAsync().ConfigureAwait(false); + if (hasNext) { - hasNext = await e.MoveNextAsync().ConfigureAwait(false); - if (hasNext) - { - value = e.Current; - } + value = e.Current; } - catch (Exception ex) + } + catch (Exception ex) + { + if (!ctd.Token.IsCancellationRequested) { - if (!ctd.Token.IsCancellationRequested) - { - observer.OnError(ex); - } - - return; + observer.OnError(ex); } - if (!hasNext) - { - observer.OnCompleted(); - return; - } + return; + } - observer.OnNext(value); + if (!hasNext) + { + observer.OnCompleted(); + return; } - while (!ctd.Token.IsCancellationRequested); + + observer.OnNext(value); } + while (!ctd.Token.IsCancellationRequested); } // Fire and forget diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Union.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Union.cs index c3d26418cc..1537a05d2f 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Union.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/Union.cs @@ -52,7 +52,9 @@ private static bool AreEqualityComparersEqual(IEqualityComparerThe type of the source enumerables. private abstract class UnionAsyncIterator : AsyncIterator, IAsyncIListProvider { +#pragma warning disable IDE1006 // Naming Styles internal readonly IEqualityComparer? _comparer; +#pragma warning restore IDE1006 // Naming Styles private IAsyncEnumerator? _enumerator; private Set? _set; private int _index; diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Set.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Set.cs index a6b9d93c86..fea0c69ecf 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Linq/Set.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Linq/Set.cs @@ -145,9 +145,11 @@ private void Resize() private struct Slot { +#pragma warning disable IDE1006 // Naming Styles internal int _hashCode; internal int _next; internal TElement _value; +#pragma warning restore IDE1006 // Naming Styles } } } diff --git a/Ix.NET/Source/System.Linq.Async/System/Threading/Tasks/AsyncEnumerableExt.cs b/Ix.NET/Source/System.Linq.Async/System/Threading/Tasks/AsyncEnumerableExt.cs index 5795fadddf..d67240b30c 100644 --- a/Ix.NET/Source/System.Linq.Async/System/Threading/Tasks/AsyncEnumerableExt.cs +++ b/Ix.NET/Source/System.Linq.Async/System/Threading/Tasks/AsyncEnumerableExt.cs @@ -9,7 +9,13 @@ namespace System.Threading.Tasks { internal static class AsyncEnumerableExt { +#if NET6_0_OR_GREATER +#pragma warning disable CA1068 // CancellationToken parameters must come last. The arguments in favour of doing that also apply to the continueOnCapturedContext parameter +#endif public static ConfiguredCancelableAsyncEnumerable.Enumerator GetConfiguredAsyncEnumerator(this IAsyncEnumerable enumerable, CancellationToken cancellationToken, bool continueOnCapturedContext) +#if NET6_0_OR_GREATER +#pragma warning restore CA1068 +#endif { return enumerable.ConfigureAwait(continueOnCapturedContext).WithCancellation(cancellationToken).GetAsyncEnumerator(); } diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractive.verified.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractive.verified.cs new file mode 100644 index 0000000000..36c17c5560 --- /dev/null +++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractive.verified.cs @@ -0,0 +1,104 @@ +[assembly: System.CLSCompliant(true)] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.ComVisible(false)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName=".NET 6.0")] +namespace System.Linq +{ + public static class EnumerableEx + { + public static System.Collections.Generic.IEnumerable> Buffer(this System.Collections.Generic.IEnumerable source, int count) { } + public static System.Collections.Generic.IEnumerable> Buffer(this System.Collections.Generic.IEnumerable source, int count, int skip) { } + public static System.Collections.Generic.IEnumerable Case(System.Func selector, System.Collections.Generic.IDictionary> sources) { } + public static System.Collections.Generic.IEnumerable Case(System.Func selector, System.Collections.Generic.IDictionary> sources, System.Collections.Generic.IEnumerable defaultSource) { } + public static System.Collections.Generic.IEnumerable Catch(params System.Collections.Generic.IEnumerable[] sources) { } + public static System.Collections.Generic.IEnumerable Catch(this System.Collections.Generic.IEnumerable> sources) { } + public static System.Collections.Generic.IEnumerable Catch(this System.Collections.Generic.IEnumerable first, System.Collections.Generic.IEnumerable second) { } + public static System.Collections.Generic.IEnumerable Catch(this System.Collections.Generic.IEnumerable source, System.Func> handler) + where TException : System.Exception { } + public static System.Collections.Generic.IEnumerable Concat(params System.Collections.Generic.IEnumerable[] sources) { } + public static System.Collections.Generic.IEnumerable Concat(this System.Collections.Generic.IEnumerable> sources) { } + public static System.Collections.Generic.IEnumerable Create(System.Action> create) { } + public static System.Collections.Generic.IEnumerable Create(System.Func> getEnumerator) { } + public static System.Collections.Generic.IEnumerable Defer(System.Func> enumerableFactory) { } + public static System.Collections.Generic.IEnumerable Distinct(this System.Collections.Generic.IEnumerable source, System.Func keySelector) { } + public static System.Collections.Generic.IEnumerable Distinct(this System.Collections.Generic.IEnumerable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Collections.Generic.IEnumerable DistinctUntilChanged(this System.Collections.Generic.IEnumerable source) { } + public static System.Collections.Generic.IEnumerable DistinctUntilChanged(this System.Collections.Generic.IEnumerable source, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Collections.Generic.IEnumerable DistinctUntilChanged(this System.Collections.Generic.IEnumerable source, System.Func keySelector) { } + public static System.Collections.Generic.IEnumerable DistinctUntilChanged(this System.Collections.Generic.IEnumerable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Collections.Generic.IEnumerable Do(this System.Collections.Generic.IEnumerable source, System.Action onNext) { } + public static System.Collections.Generic.IEnumerable Do(this System.Collections.Generic.IEnumerable source, System.IObserver observer) { } + public static System.Collections.Generic.IEnumerable Do(this System.Collections.Generic.IEnumerable source, System.Action onNext, System.Action onCompleted) { } + public static System.Collections.Generic.IEnumerable Do(this System.Collections.Generic.IEnumerable source, System.Action onNext, System.Action onError) { } + public static System.Collections.Generic.IEnumerable Do(this System.Collections.Generic.IEnumerable source, System.Action onNext, System.Action onError, System.Action onCompleted) { } + public static System.Collections.Generic.IEnumerable DoWhile(this System.Collections.Generic.IEnumerable source, System.Func condition) { } + public static System.Collections.Generic.IEnumerable Expand(this System.Collections.Generic.IEnumerable source, System.Func> selector) { } + public static System.Collections.Generic.IEnumerable Finally(this System.Collections.Generic.IEnumerable source, System.Action finallyAction) { } + public static System.Collections.Generic.IEnumerable For(System.Collections.Generic.IEnumerable source, System.Func> resultSelector) { } + public static void ForEach(this System.Collections.Generic.IEnumerable source, System.Action onNext) { } + public static void ForEach(this System.Collections.Generic.IEnumerable source, System.Action onNext) { } + public static System.Collections.Generic.IEnumerable Generate(TState initialState, System.Func condition, System.Func iterate, System.Func resultSelector) { } + public static System.Collections.Generic.IEnumerable Hide(this System.Collections.Generic.IEnumerable source) { } + public static System.Collections.Generic.IEnumerable If(System.Func condition, System.Collections.Generic.IEnumerable thenSource) { } + public static System.Collections.Generic.IEnumerable If(System.Func condition, System.Collections.Generic.IEnumerable thenSource, System.Collections.Generic.IEnumerable elseSource) { } + public static System.Collections.Generic.IEnumerable IgnoreElements(this System.Collections.Generic.IEnumerable source) { } + public static bool IsEmpty(this System.Collections.Generic.IEnumerable source) { } + public static TSource Max(this System.Collections.Generic.IEnumerable source, System.Collections.Generic.IComparer comparer) { } + [System.Obsolete("Use MaxByWithTies to maintain same behavior with .NET 6 and later", false)] + public static System.Collections.Generic.IList MaxBy(this System.Collections.Generic.IEnumerable source, System.Func keySelector) { } + [System.Obsolete("Use MaxByWithTies to maintain same behavior with .NET 6 and later", false)] + public static System.Collections.Generic.IList MaxBy(this System.Collections.Generic.IEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IList MaxByWithTies(this System.Collections.Generic.IEnumerable source, System.Func keySelector) { } + public static System.Collections.Generic.IList MaxByWithTies(this System.Collections.Generic.IEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Linq.IBuffer Memoize(this System.Collections.Generic.IEnumerable source) { } + public static System.Linq.IBuffer Memoize(this System.Collections.Generic.IEnumerable source, int readerCount) { } + public static System.Collections.Generic.IEnumerable Memoize(this System.Collections.Generic.IEnumerable source, System.Func, System.Collections.Generic.IEnumerable> selector) { } + public static System.Collections.Generic.IEnumerable Memoize(this System.Collections.Generic.IEnumerable source, int readerCount, System.Func, System.Collections.Generic.IEnumerable> selector) { } + public static TSource Min(this System.Collections.Generic.IEnumerable source, System.Collections.Generic.IComparer comparer) { } + [System.Obsolete("Use MinByWithTies to maintain same behavior with .NET 6 and later", false)] + public static System.Collections.Generic.IList MinBy(this System.Collections.Generic.IEnumerable source, System.Func keySelector) { } + [System.Obsolete("Use MinByWithTies to maintain same behavior with .NET 6 and later", false)] + public static System.Collections.Generic.IList MinBy(this System.Collections.Generic.IEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IList MinByWithTies(this System.Collections.Generic.IEnumerable source, System.Func keySelector) { } + public static System.Collections.Generic.IList MinByWithTies(this System.Collections.Generic.IEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IEnumerable OnErrorResumeNext(params System.Collections.Generic.IEnumerable[] sources) { } + public static System.Collections.Generic.IEnumerable OnErrorResumeNext(this System.Collections.Generic.IEnumerable> sources) { } + public static System.Collections.Generic.IEnumerable OnErrorResumeNext(this System.Collections.Generic.IEnumerable first, System.Collections.Generic.IEnumerable second) { } + public static System.Linq.IBuffer Publish(this System.Collections.Generic.IEnumerable source) { } + public static System.Collections.Generic.IEnumerable Publish(this System.Collections.Generic.IEnumerable source, System.Func, System.Collections.Generic.IEnumerable> selector) { } + public static System.Collections.Generic.IEnumerable Repeat(TResult value) { } + public static System.Collections.Generic.IEnumerable Repeat(this System.Collections.Generic.IEnumerable source) { } + public static System.Collections.Generic.IEnumerable Repeat(TResult element, int count) { } + public static System.Collections.Generic.IEnumerable Repeat(this System.Collections.Generic.IEnumerable source, int count) { } + public static System.Collections.Generic.IEnumerable Retry(this System.Collections.Generic.IEnumerable source) { } + public static System.Collections.Generic.IEnumerable Retry(this System.Collections.Generic.IEnumerable source, int retryCount) { } + public static System.Collections.Generic.IEnumerable Return(TResult value) { } + public static System.Collections.Generic.IEnumerable Scan(this System.Collections.Generic.IEnumerable source, System.Func accumulator) { } + public static System.Collections.Generic.IEnumerable Scan(this System.Collections.Generic.IEnumerable source, TAccumulate seed, System.Func accumulator) { } + public static System.Collections.Generic.IEnumerable SelectMany(this System.Collections.Generic.IEnumerable source, System.Collections.Generic.IEnumerable other) { } + public static System.Linq.IBuffer Share(this System.Collections.Generic.IEnumerable source) { } + public static System.Collections.Generic.IEnumerable Share(this System.Collections.Generic.IEnumerable source, System.Func, System.Collections.Generic.IEnumerable> selector) { } + public static System.Collections.Generic.IEnumerable SkipLast(this System.Collections.Generic.IEnumerable source, int count) { } + public static System.Collections.Generic.IEnumerable StartWith(this System.Collections.Generic.IEnumerable source, params TSource[] values) { } + public static System.Collections.Generic.IEnumerable TakeLast(this System.Collections.Generic.IEnumerable source, int count) { } + public static System.Collections.Generic.IEnumerable Throw(System.Exception exception) { } + public static System.Collections.Generic.IEnumerable Using(System.Func resourceFactory, System.Func> enumerableFactory) + where TResource : System.IDisposable { } + public static System.Collections.Generic.IEnumerable While(System.Func condition, System.Collections.Generic.IEnumerable source) { } + } + public interface IAwaitable + { + System.Linq.IAwaiter GetAwaiter(); + } + public interface IAwaiter : System.Runtime.CompilerServices.ICriticalNotifyCompletion, System.Runtime.CompilerServices.INotifyCompletion + { + bool IsCompleted { get; } + void GetResult(); + } + public interface IBuffer : System.Collections.Generic.IEnumerable, System.Collections.IEnumerable, System.IDisposable { } + public interface IYielder + { + System.Linq.IAwaitable Break(); + System.Linq.IAwaitable Return(T value); + } +} diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.verified.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.verified.cs new file mode 100644 index 0000000000..067c121704 --- /dev/null +++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsync.verified.cs @@ -0,0 +1,108 @@ +[assembly: System.CLSCompliant(true)] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.ComVisible(false)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName=".NET 6.0")] +namespace System.Linq +{ + public static class AsyncEnumerableEx + { + public static System.Collections.Generic.IAsyncEnumerable Amb(params System.Collections.Generic.IAsyncEnumerable[] sources) { } + public static System.Collections.Generic.IAsyncEnumerable Amb(this System.Collections.Generic.IEnumerable> sources) { } + public static System.Collections.Generic.IAsyncEnumerable Amb(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Collections.Generic.IAsyncEnumerable> Buffer(this System.Collections.Generic.IAsyncEnumerable source, int count) { } + public static System.Collections.Generic.IAsyncEnumerable> Buffer(this System.Collections.Generic.IAsyncEnumerable source, int count, int skip) { } + public static System.Collections.Generic.IAsyncEnumerable Catch(params System.Collections.Generic.IAsyncEnumerable[] sources) { } + public static System.Collections.Generic.IAsyncEnumerable Catch(this System.Collections.Generic.IEnumerable> sources) { } + public static System.Collections.Generic.IAsyncEnumerable Catch(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Collections.Generic.IAsyncEnumerable Catch(this System.Collections.Generic.IAsyncEnumerable source, System.Func> handler) + where TException : System.Exception { } + public static System.Collections.Generic.IAsyncEnumerable Catch(this System.Collections.Generic.IAsyncEnumerable source, System.Func>> handler) + where TException : System.Exception { } + public static System.Collections.Generic.IAsyncEnumerable Catch(this System.Collections.Generic.IAsyncEnumerable source, System.Func>> handler) + where TException : System.Exception { } + public static System.Collections.Generic.IAsyncEnumerable Concat(params System.Collections.Generic.IAsyncEnumerable[] sources) { } + public static System.Collections.Generic.IAsyncEnumerable Concat(this System.Collections.Generic.IAsyncEnumerable> sources) { } + public static System.Collections.Generic.IAsyncEnumerable Concat(this System.Collections.Generic.IEnumerable> sources) { } + public static System.Collections.Generic.IAsyncEnumerable Defer(System.Func> factory) { } + public static System.Collections.Generic.IAsyncEnumerable Defer(System.Func>> factory) { } + public static System.Collections.Generic.IAsyncEnumerable Defer(System.Func>> factory) { } + public static System.Collections.Generic.IAsyncEnumerable Distinct(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector) { } + public static System.Collections.Generic.IAsyncEnumerable Distinct(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector) { } + public static System.Collections.Generic.IAsyncEnumerable Distinct(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector) { } + public static System.Collections.Generic.IAsyncEnumerable Distinct(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable Distinct(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable Distinct(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable DistinctUntilChanged(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Collections.Generic.IAsyncEnumerable DistinctUntilChanged(this System.Collections.Generic.IAsyncEnumerable source, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable DistinctUntilChanged(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector) { } + public static System.Collections.Generic.IAsyncEnumerable DistinctUntilChanged(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector) { } + public static System.Collections.Generic.IAsyncEnumerable DistinctUntilChanged(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector) { } + public static System.Collections.Generic.IAsyncEnumerable DistinctUntilChanged(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable DistinctUntilChanged(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable DistinctUntilChanged(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.Action onNext) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.Func onNext) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.Func onNext) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.IObserver observer) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.Action onNext, System.Action onCompleted) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.Action onNext, System.Action onError) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.Func onNext, System.Func onCompleted) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.Func onNext, System.Func onError) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.Func onNext, System.Func onCompleted) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.Func onNext, System.Func onError) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.Action onNext, System.Action onError, System.Action onCompleted) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.Func onNext, System.Func onError, System.Func onCompleted) { } + public static System.Collections.Generic.IAsyncEnumerable Do(this System.Collections.Generic.IAsyncEnumerable source, System.Func onNext, System.Func onError, System.Func onCompleted) { } + public static System.Collections.Generic.IAsyncEnumerable Expand(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector) { } + public static System.Collections.Generic.IAsyncEnumerable Expand(this System.Collections.Generic.IAsyncEnumerable source, System.Func>> selector) { } + public static System.Collections.Generic.IAsyncEnumerable Expand(this System.Collections.Generic.IAsyncEnumerable source, System.Func>> selector) { } + public static System.Collections.Generic.IAsyncEnumerable Finally(this System.Collections.Generic.IAsyncEnumerable source, System.Action finallyAction) { } + public static System.Collections.Generic.IAsyncEnumerable Finally(this System.Collections.Generic.IAsyncEnumerable source, System.Func finallyAction) { } + public static System.Collections.Generic.IAsyncEnumerable Generate(TState initialState, System.Func condition, System.Func iterate, System.Func resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable IgnoreElements(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Threading.Tasks.ValueTask IsEmptyAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MaxByAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MaxByAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MaxByAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MaxByAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MaxByAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MaxByAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Collections.Generic.IAsyncEnumerable Merge(params System.Collections.Generic.IAsyncEnumerable[] sources) { } + public static System.Collections.Generic.IAsyncEnumerable Merge(this System.Collections.Generic.IAsyncEnumerable> sources) { } + public static System.Collections.Generic.IAsyncEnumerable Merge(this System.Collections.Generic.IEnumerable> sources) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MinByAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MinByAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MinByAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MinByAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MinByAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MinByAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IComparer comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Collections.Generic.IAsyncEnumerable Never() { } + public static System.Collections.Generic.IAsyncEnumerable OnErrorResumeNext(params System.Collections.Generic.IAsyncEnumerable[] sources) { } + public static System.Collections.Generic.IAsyncEnumerable OnErrorResumeNext(this System.Collections.Generic.IEnumerable> sources) { } + public static System.Collections.Generic.IAsyncEnumerable OnErrorResumeNext(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Collections.Generic.IAsyncEnumerable Repeat(TResult element) { } + public static System.Collections.Generic.IAsyncEnumerable Repeat(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Collections.Generic.IAsyncEnumerable Repeat(this System.Collections.Generic.IAsyncEnumerable source, int count) { } + public static System.Collections.Generic.IAsyncEnumerable Retry(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Collections.Generic.IAsyncEnumerable Retry(this System.Collections.Generic.IAsyncEnumerable source, int retryCount) { } + public static System.Collections.Generic.IAsyncEnumerable Return(TValue value) { } + public static System.Collections.Generic.IAsyncEnumerable Scan(this System.Collections.Generic.IAsyncEnumerable source, System.Func> accumulator) { } + public static System.Collections.Generic.IAsyncEnumerable Scan(this System.Collections.Generic.IAsyncEnumerable source, System.Func accumulator) { } + public static System.Collections.Generic.IAsyncEnumerable Scan(this System.Collections.Generic.IAsyncEnumerable source, System.Func> accumulator) { } + public static System.Collections.Generic.IAsyncEnumerable Scan(this System.Collections.Generic.IAsyncEnumerable source, TAccumulate seed, System.Func> accumulator) { } + public static System.Collections.Generic.IAsyncEnumerable Scan(this System.Collections.Generic.IAsyncEnumerable source, TAccumulate seed, System.Func accumulator) { } + public static System.Collections.Generic.IAsyncEnumerable Scan(this System.Collections.Generic.IAsyncEnumerable source, TAccumulate seed, System.Func> accumulator) { } + public static System.Collections.Generic.IAsyncEnumerable SelectMany(this System.Collections.Generic.IAsyncEnumerable source, System.Collections.Generic.IAsyncEnumerable other) { } + public static System.Collections.Generic.IAsyncEnumerable StartWith(this System.Collections.Generic.IAsyncEnumerable source, params TSource[] values) { } + public static System.Collections.Generic.IAsyncEnumerable Throw(System.Exception exception) { } + public static System.Collections.Generic.IAsyncEnumerable Timeout(this System.Collections.Generic.IAsyncEnumerable source, System.TimeSpan timeout) { } + public static System.Collections.Generic.IAsyncEnumerable Using(System.Func> resourceFactory, System.Func>> enumerableFactory) + where TResource : System.IDisposable { } + public static System.Collections.Generic.IAsyncEnumerable Using(System.Func resourceFactory, System.Func> enumerableFactory) + where TResource : System.IDisposable { } + public static System.Collections.Generic.IAsyncEnumerable Using(System.Func> resourceFactory, System.Func>> enumerableFactory) + where TResource : System.IDisposable { } + } +} \ No newline at end of file diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.verified.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.verified.cs new file mode 100644 index 0000000000..a51d1bc7c1 --- /dev/null +++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveAsyncProviders.verified.cs @@ -0,0 +1,82 @@ +[assembly: System.CLSCompliant(true)] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.ComVisible(false)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName=".NET 6.0")] +namespace System.Linq +{ + [System.Linq.LocalQueryMethodImplementationType(typeof(System.Linq.AsyncEnumerableEx))] + public static class AsyncQueryableEx + { + public static System.Linq.IAsyncQueryable Amb(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Linq.IAsyncQueryable> Buffer(this System.Linq.IAsyncQueryable source, int count) { } + public static System.Linq.IAsyncQueryable> Buffer(this System.Linq.IAsyncQueryable source, int count, int skip) { } + public static System.Linq.IAsyncQueryable Catch(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Linq.IAsyncQueryable Catch(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> handler) { } + public static System.Linq.IAsyncQueryable Catch(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>>> handler) { } + public static System.Linq.IAsyncQueryable Catch(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>>> handler) { } + public static System.Linq.IAsyncQueryable Concat(this System.Linq.IAsyncQueryable> sources) { } + public static System.Linq.IAsyncQueryable Distinct(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IAsyncQueryable Distinct(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Linq.IAsyncQueryable Distinct(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IAsyncQueryable Distinct(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable Distinct(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable Distinct(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable DistinctUntilChanged(this System.Linq.IAsyncQueryable source) { } + public static System.Linq.IAsyncQueryable DistinctUntilChanged(this System.Linq.IAsyncQueryable source, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable DistinctUntilChanged(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IAsyncQueryable DistinctUntilChanged(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Linq.IAsyncQueryable DistinctUntilChanged(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IAsyncQueryable DistinctUntilChanged(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable DistinctUntilChanged(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable DistinctUntilChanged(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.IObserver observer) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> onNext) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> onNext) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> onNext) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> onNext, System.Action onCompleted) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression> onError) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression> onCompleted) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression> onError) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression> onCompleted) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression> onError) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression> onError, System.Action onCompleted) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression> onError, System.Linq.Expressions.Expression> onCompleted) { } + public static System.Linq.IAsyncQueryable Do(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression> onError, System.Linq.Expressions.Expression> onCompleted) { } + public static System.Linq.IAsyncQueryable Expand(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Linq.IAsyncQueryable Expand(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>>> selector) { } + public static System.Linq.IAsyncQueryable Expand(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>>> selector) { } + public static System.Linq.IAsyncQueryable Finally(this System.Linq.IAsyncQueryable source, System.Action finallyAction) { } + public static System.Linq.IAsyncQueryable Finally(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> finallyAction) { } + public static System.Linq.IAsyncQueryable IgnoreElements(this System.Linq.IAsyncQueryable source) { } + public static System.Threading.Tasks.ValueTask IsEmptyAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MaxByAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MaxByAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MaxByAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MaxByAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MaxByAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MaxByAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Linq.IAsyncQueryable Merge(this System.Linq.IAsyncQueryable> sources) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MinByAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MinByAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MinByAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MinByAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MinByAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> MinByAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Linq.IAsyncQueryable OnErrorResumeNext(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Linq.IAsyncQueryable Repeat(this System.Linq.IAsyncQueryable source) { } + public static System.Linq.IAsyncQueryable Repeat(this System.Linq.IAsyncQueryable source, int count) { } + public static System.Linq.IAsyncQueryable Retry(this System.Linq.IAsyncQueryable source) { } + public static System.Linq.IAsyncQueryable Retry(this System.Linq.IAsyncQueryable source, int retryCount) { } + public static System.Linq.IAsyncQueryable Scan(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> accumulator) { } + public static System.Linq.IAsyncQueryable Scan(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> accumulator) { } + public static System.Linq.IAsyncQueryable Scan(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> accumulator) { } + public static System.Linq.IAsyncQueryable Scan(this System.Linq.IAsyncQueryable source, TAccumulate seed, System.Linq.Expressions.Expression>> accumulator) { } + public static System.Linq.IAsyncQueryable Scan(this System.Linq.IAsyncQueryable source, TAccumulate seed, System.Linq.Expressions.Expression> accumulator) { } + public static System.Linq.IAsyncQueryable Scan(this System.Linq.IAsyncQueryable source, TAccumulate seed, System.Linq.Expressions.Expression>> accumulator) { } + public static System.Linq.IAsyncQueryable SelectMany(this System.Linq.IAsyncQueryable source, System.Collections.Generic.IAsyncEnumerable other) { } + public static System.Linq.IAsyncQueryable StartWith(this System.Linq.IAsyncQueryable source, params TSource[] values) { } + public static System.Linq.IAsyncQueryable Timeout(this System.Linq.IAsyncQueryable source, System.TimeSpan timeout) { } + } +} \ No newline at end of file diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveProviders.verified.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveProviders.verified.cs new file mode 100644 index 0000000000..3621d54850 --- /dev/null +++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemInteractiveProviders.verified.cs @@ -0,0 +1,147 @@ +[assembly: System.CLSCompliant(true)] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.ComVisible(false)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName=".NET 6.0")] +namespace System.Linq +{ + public static class QueryableEx + { + public static System.Linq.IQueryProvider Provider { get; } + public static System.Collections.Generic.IEnumerable> Buffer(System.Collections.Generic.IEnumerable source, int count) { } + public static System.Linq.IQueryable> Buffer(this System.Linq.IQueryable source, int count) { } + public static System.Collections.Generic.IEnumerable> Buffer(System.Collections.Generic.IEnumerable source, int count, int skip) { } + public static System.Linq.IQueryable> Buffer(this System.Linq.IQueryable source, int count, int skip) { } + public static System.Linq.IQueryable Case(System.Func selector, System.Collections.Generic.IDictionary> sources) { } + public static System.Linq.IQueryable Case(System.Func selector, System.Collections.Generic.IDictionary> sources, System.Collections.Generic.IEnumerable defaultSource) { } + public static System.Linq.IQueryable Case(this System.Linq.IQueryProvider provider, System.Linq.Expressions.Expression> selector, System.Collections.Generic.IDictionary> sources) { } + public static System.Linq.IQueryable Case(this System.Linq.IQueryProvider provider, System.Linq.Expressions.Expression> selector, System.Collections.Generic.IDictionary> sources, System.Collections.Generic.IEnumerable defaultSource) { } + public static System.Collections.Generic.IEnumerable Catch(System.Collections.Generic.IEnumerable> sources) { } + public static System.Linq.IQueryable Catch(params System.Collections.Generic.IEnumerable[] sources) { } + public static System.Linq.IQueryable Catch(this System.Linq.IQueryable> sources) { } + public static System.Collections.Generic.IEnumerable Catch(System.Collections.Generic.IEnumerable first, System.Collections.Generic.IEnumerable second) { } + public static System.Linq.IQueryable Catch(this System.Linq.IQueryProvider provider, params System.Collections.Generic.IEnumerable[] sources) { } + public static System.Linq.IQueryable Catch(this System.Linq.IQueryable first, System.Collections.Generic.IEnumerable second) { } + public static System.Collections.Generic.IEnumerable Catch(System.Collections.Generic.IEnumerable source, System.Func> handler) + where TException : System.Exception { } + public static System.Linq.IQueryable Catch(this System.Linq.IQueryable source, System.Linq.Expressions.Expression>> handler) + where TException : System.Exception { } + public static System.Collections.Generic.IEnumerable Concat(System.Collections.Generic.IEnumerable> sources) { } + public static System.Linq.IQueryable Concat(params System.Collections.Generic.IEnumerable[] sources) { } + public static System.Linq.IQueryable Concat(this System.Linq.IQueryable> sources) { } + public static System.Linq.IQueryable Concat(this System.Linq.IQueryProvider provider, params System.Collections.Generic.IEnumerable[] sources) { } + public static System.Collections.Generic.IEnumerable Create(System.Func> getEnumerator) { } + public static System.Linq.IQueryable Create(this System.Linq.IQueryProvider provider, System.Linq.Expressions.Expression>> getEnumerator) { } + public static System.Linq.IQueryable Defer(System.Func> enumerableFactory) { } + public static System.Linq.IQueryable Defer(this System.Linq.IQueryProvider provider, System.Linq.Expressions.Expression>> enumerableFactory) { } + public static System.Collections.Generic.IEnumerable Distinct(System.Collections.Generic.IEnumerable source, System.Func keySelector) { } + public static System.Linq.IQueryable Distinct(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Collections.Generic.IEnumerable Distinct(System.Collections.Generic.IEnumerable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Linq.IQueryable Distinct(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Collections.Generic.IEnumerable DistinctUntilChanged(System.Collections.Generic.IEnumerable source) { } + public static System.Linq.IQueryable DistinctUntilChanged(this System.Linq.IQueryable source) { } + public static System.Collections.Generic.IEnumerable DistinctUntilChanged(System.Collections.Generic.IEnumerable source, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Linq.IQueryable DistinctUntilChanged(this System.Linq.IQueryable source, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Collections.Generic.IEnumerable DistinctUntilChanged(System.Collections.Generic.IEnumerable source, System.Func keySelector) { } + public static System.Linq.IQueryable DistinctUntilChanged(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Collections.Generic.IEnumerable DistinctUntilChanged(System.Collections.Generic.IEnumerable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Linq.IQueryable DistinctUntilChanged(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IEqualityComparer comparer) { } + public static System.Collections.Generic.IEnumerable Do(System.Collections.Generic.IEnumerable source, System.Action onNext) { } + public static System.Collections.Generic.IEnumerable Do(System.Collections.Generic.IEnumerable source, System.IObserver observer) { } + public static System.Linq.IQueryable Do(this System.Linq.IQueryable source, System.IObserver observer) { } + public static System.Linq.IQueryable Do(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> onNext) { } + public static System.Collections.Generic.IEnumerable Do(System.Collections.Generic.IEnumerable source, System.Action onNext, System.Action onCompleted) { } + public static System.Collections.Generic.IEnumerable Do(System.Collections.Generic.IEnumerable source, System.Action onNext, System.Action onError) { } + public static System.Linq.IQueryable Do(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression onCompleted) { } + public static System.Linq.IQueryable Do(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression> onError) { } + public static System.Collections.Generic.IEnumerable Do(System.Collections.Generic.IEnumerable source, System.Action onNext, System.Action onError, System.Action onCompleted) { } + public static System.Linq.IQueryable Do(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> onNext, System.Linq.Expressions.Expression> onError, System.Linq.Expressions.Expression onCompleted) { } + public static System.Collections.Generic.IEnumerable DoWhile(System.Collections.Generic.IEnumerable source, System.Func condition) { } + public static System.Linq.IQueryable DoWhile(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> condition) { } + public static System.Linq.IQueryable Empty() { } + public static System.Linq.IQueryable Empty(this System.Linq.IQueryProvider provider) { } + public static System.Collections.Generic.IEnumerable Expand(System.Collections.Generic.IEnumerable source, System.Func> selector) { } + public static System.Linq.IQueryable Expand(this System.Linq.IQueryable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Collections.Generic.IEnumerable Finally(System.Collections.Generic.IEnumerable source, System.Action finallyAction) { } + public static System.Linq.IQueryable Finally(this System.Linq.IQueryable source, System.Linq.Expressions.Expression finallyAction) { } + public static System.Linq.IQueryable For(System.Collections.Generic.IEnumerable source, System.Func> resultSelector) { } + public static System.Linq.IQueryable For(this System.Linq.IQueryProvider provider, System.Collections.Generic.IEnumerable source, System.Linq.Expressions.Expression>> resultSelector) { } + public static System.Linq.IQueryable Generate(TState initialState, System.Func condition, System.Func iterate, System.Func resultSelector) { } + public static System.Linq.IQueryable Generate(this System.Linq.IQueryProvider provider, TState initialState, System.Linq.Expressions.Expression> condition, System.Linq.Expressions.Expression> iterate, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Collections.Generic.IEnumerable Hide(System.Collections.Generic.IEnumerable source) { } + public static System.Linq.IQueryable Hide(this System.Linq.IQueryable source) { } + public static System.Linq.IQueryable If(System.Func condition, System.Collections.Generic.IEnumerable thenSource) { } + public static System.Linq.IQueryable If(System.Func condition, System.Collections.Generic.IEnumerable thenSource, System.Collections.Generic.IEnumerable elseSource) { } + public static System.Linq.IQueryable If(this System.Linq.IQueryProvider provider, System.Linq.Expressions.Expression> condition, System.Collections.Generic.IEnumerable thenSource) { } + public static System.Linq.IQueryable If(this System.Linq.IQueryProvider provider, System.Linq.Expressions.Expression> condition, System.Collections.Generic.IEnumerable thenSource, System.Collections.Generic.IEnumerable elseSource) { } + public static System.Collections.Generic.IEnumerable IgnoreElements(System.Collections.Generic.IEnumerable source) { } + public static System.Linq.IQueryable IgnoreElements(this System.Linq.IQueryable source) { } + public static bool IsEmpty(System.Collections.Generic.IEnumerable source) { } + public static bool IsEmpty(this System.Linq.IQueryable source) { } + public static TSource Max(System.Collections.Generic.IEnumerable source, System.Collections.Generic.IComparer comparer) { } + public static TSource Max(this System.Linq.IQueryable source, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IList MaxBy(System.Collections.Generic.IEnumerable source, System.Func keySelector) { } + public static System.Collections.Generic.IList MaxBy(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Collections.Generic.IList MaxBy(System.Collections.Generic.IEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IList MaxBy(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IList MaxByWithTies(System.Collections.Generic.IEnumerable source, System.Func keySelector) { } + public static System.Collections.Generic.IList MaxByWithTies(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Collections.Generic.IEnumerable Memoize(System.Collections.Generic.IEnumerable source, System.Func, System.Collections.Generic.IEnumerable> selector) { } + public static System.Linq.IQueryable Memoize(this System.Linq.IQueryable source, System.Linq.Expressions.Expression, System.Collections.Generic.IEnumerable>> selector) { } + public static System.Collections.Generic.IEnumerable Memoize(System.Collections.Generic.IEnumerable source, int readerCount, System.Func, System.Collections.Generic.IEnumerable> selector) { } + public static System.Linq.IQueryable Memoize(this System.Linq.IQueryable source, int readerCount, System.Linq.Expressions.Expression, System.Collections.Generic.IEnumerable>> selector) { } + public static TSource Min(System.Collections.Generic.IEnumerable source, System.Collections.Generic.IComparer comparer) { } + public static TSource Min(this System.Linq.IQueryable source, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IList MinBy(System.Collections.Generic.IEnumerable source, System.Func keySelector) { } + public static System.Collections.Generic.IList MinBy(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Collections.Generic.IList MinBy(System.Collections.Generic.IEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IList MinBy(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IList MinByWithTies(System.Collections.Generic.IEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IList MinByWithTies(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IEnumerable OnErrorResumeNext(System.Collections.Generic.IEnumerable> sources) { } + public static System.Linq.IQueryable OnErrorResumeNext(params System.Collections.Generic.IEnumerable[] sources) { } + public static System.Linq.IQueryable OnErrorResumeNext(this System.Linq.IQueryable> sources) { } + public static System.Collections.Generic.IEnumerable OnErrorResumeNext(System.Collections.Generic.IEnumerable first, System.Collections.Generic.IEnumerable second) { } + public static System.Collections.Generic.IEnumerable OnErrorResumeNext(this System.Linq.IQueryProvider provider, params System.Collections.Generic.IEnumerable[] sources) { } + public static System.Linq.IQueryable OnErrorResumeNext(this System.Linq.IQueryable first, System.Collections.Generic.IEnumerable second) { } + public static System.Collections.Generic.IEnumerable Publish(System.Collections.Generic.IEnumerable source, System.Func, System.Collections.Generic.IEnumerable> selector) { } + public static System.Linq.IQueryable Publish(this System.Linq.IQueryable source, System.Linq.Expressions.Expression, System.Collections.Generic.IEnumerable>> selector) { } + public static System.Linq.IQueryable Range(int start, int count) { } + public static System.Linq.IQueryable Range(this System.Linq.IQueryProvider provider, int start, int count) { } + public static System.Collections.Generic.IEnumerable Repeat(System.Collections.Generic.IEnumerable source) { } + public static System.Linq.IQueryable Repeat(TResult value) { } + public static System.Linq.IQueryable Repeat(this System.Linq.IQueryable source) { } + public static System.Collections.Generic.IEnumerable Repeat(System.Collections.Generic.IEnumerable source, int count) { } + public static System.Linq.IQueryable Repeat(TResult element, int count) { } + public static System.Collections.Generic.IEnumerable Repeat(this System.Linq.IQueryProvider provider, TResult value) { } + public static System.Linq.IQueryable Repeat(this System.Linq.IQueryable source, int count) { } + public static System.Linq.IQueryable Repeat(this System.Linq.IQueryProvider provider, TResult element, int count) { } + public static System.Collections.Generic.IEnumerable Retry(System.Collections.Generic.IEnumerable source) { } + public static System.Linq.IQueryable Retry(this System.Linq.IQueryable source) { } + public static System.Collections.Generic.IEnumerable Retry(System.Collections.Generic.IEnumerable source, int retryCount) { } + public static System.Linq.IQueryable Retry(this System.Linq.IQueryable source, int retryCount) { } + public static System.Linq.IQueryable Return(TResult value) { } + public static System.Linq.IQueryable Return(this System.Linq.IQueryProvider provider, TResult value) { } + public static System.Collections.Generic.IEnumerable Scan(System.Collections.Generic.IEnumerable source, System.Func accumulator) { } + public static System.Linq.IQueryable Scan(this System.Linq.IQueryable source, System.Linq.Expressions.Expression> accumulator) { } + public static System.Collections.Generic.IEnumerable Scan(System.Collections.Generic.IEnumerable source, TAccumulate seed, System.Func accumulator) { } + public static System.Linq.IQueryable Scan(this System.Linq.IQueryable source, TAccumulate seed, System.Linq.Expressions.Expression> accumulator) { } + public static System.Collections.Generic.IEnumerable SelectMany(System.Collections.Generic.IEnumerable source, System.Collections.Generic.IEnumerable other) { } + public static System.Linq.IQueryable SelectMany(this System.Linq.IQueryable source, System.Collections.Generic.IEnumerable other) { } + public static System.Collections.Generic.IEnumerable Share(System.Collections.Generic.IEnumerable source, System.Func, System.Collections.Generic.IEnumerable> selector) { } + public static System.Linq.IQueryable Share(this System.Linq.IQueryable source, System.Linq.Expressions.Expression, System.Collections.Generic.IEnumerable>> selector) { } + public static System.Collections.Generic.IEnumerable SkipLast(System.Collections.Generic.IEnumerable source, int count) { } + public static System.Linq.IQueryable SkipLast(this System.Linq.IQueryable source, int count) { } + public static System.Collections.Generic.IEnumerable StartWith(System.Collections.Generic.IEnumerable source, params TSource[] values) { } + public static System.Linq.IQueryable StartWith(this System.Linq.IQueryable source, params TSource[] values) { } + public static System.Collections.Generic.IEnumerable TakeLast(System.Collections.Generic.IEnumerable source, int count) { } + public static System.Linq.IQueryable TakeLast(this System.Linq.IQueryable source, int count) { } + public static System.Linq.IQueryable Throw(System.Exception exception) { } + public static System.Linq.IQueryable Throw(this System.Linq.IQueryProvider provider, System.Exception exception) { } + public static System.Linq.IQueryable Using(System.Func resourceFactory, System.Func> enumerableFactory) + where TResource : System.IDisposable { } + public static System.Linq.IQueryable Using(this System.Linq.IQueryProvider provider, System.Linq.Expressions.Expression> resourceFactory, System.Linq.Expressions.Expression>> enumerableFactory) + where TResource : System.IDisposable { } + public static System.Linq.IQueryable While(System.Func condition, System.Collections.Generic.IEnumerable source) { } + public static System.Linq.IQueryable While(this System.Linq.IQueryProvider provider, System.Linq.Expressions.Expression> condition, System.Collections.Generic.IEnumerable source) { } + } +} \ No newline at end of file diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.verified.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.verified.cs new file mode 100644 index 0000000000..2734bde4bb --- /dev/null +++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsync.verified.cs @@ -0,0 +1,436 @@ +[assembly: System.CLSCompliant(true)] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.ComVisible(false)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName=".NET 6.0")] +namespace System.Collections.Generic +{ + public static class AsyncEnumerator + { + public static System.Collections.Generic.IAsyncEnumerator Create(System.Func> moveNextAsync, System.Func getCurrent, System.Func disposeAsync) { } + public static System.Threading.Tasks.ValueTask MoveNextAsync(this System.Collections.Generic.IAsyncEnumerator source, System.Threading.CancellationToken cancellationToken) { } + public static System.Collections.Generic.IAsyncEnumerator WithCancellation(this System.Collections.Generic.IAsyncEnumerator source, System.Threading.CancellationToken cancellationToken) { } + } +} +namespace System.Linq +{ + public static class AsyncEnumerable + { + public static System.Threading.Tasks.ValueTask AggregateAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func accumulator, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAsync(this System.Collections.Generic.IAsyncEnumerable source, TAccumulate seed, System.Func accumulator, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAsync(this System.Collections.Generic.IAsyncEnumerable source, TAccumulate seed, System.Func accumulator, System.Func resultSelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> accumulator, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, TAccumulate seed, System.Func> accumulator, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, TAccumulate seed, System.Func> accumulator, System.Func> resultSelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> accumulator, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, TAccumulate seed, System.Func> accumulator, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, TAccumulate seed, System.Func> accumulator, System.Func> resultSelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AllAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AllAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AllAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AnyAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AnyAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AnyAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AnyAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Collections.Generic.IAsyncEnumerable Append(this System.Collections.Generic.IAsyncEnumerable source, TSource element) { } + public static System.Collections.Generic.IAsyncEnumerable AsAsyncEnumerable(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Collections.Generic.IAsyncEnumerable Cast(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Collections.Generic.IAsyncEnumerable Concat(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Threading.Tasks.ValueTask ContainsAsync(this System.Collections.Generic.IAsyncEnumerable source, TSource value, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask ContainsAsync(this System.Collections.Generic.IAsyncEnumerable source, TSource value, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask CountAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask CountAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask CountAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask CountAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Collections.Generic.IAsyncEnumerable Create(System.Func> getAsyncEnumerator) { } + public static System.Collections.Generic.IAsyncEnumerable DefaultIfEmpty(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Collections.Generic.IAsyncEnumerable DefaultIfEmpty(this System.Collections.Generic.IAsyncEnumerable source, TSource defaultValue) { } + public static System.Collections.Generic.IAsyncEnumerable Distinct(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Collections.Generic.IAsyncEnumerable Distinct(this System.Collections.Generic.IAsyncEnumerable source, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Threading.Tasks.ValueTask ElementAtAsync(this System.Collections.Generic.IAsyncEnumerable source, int index, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask ElementAtOrDefaultAsync(this System.Collections.Generic.IAsyncEnumerable source, int index, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Collections.Generic.IAsyncEnumerable Empty() { } + public static System.Collections.Generic.IAsyncEnumerable Except(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Collections.Generic.IAsyncEnumerable Except(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Threading.Tasks.ValueTask FirstAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstOrDefaultAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstOrDefaultAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstOrDefaultAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstOrDefaultAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.Task ForEachAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Action action, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.Task ForEachAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Action action, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.Task ForEachAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func action, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.Task ForEachAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func action, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.Task ForEachAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func action, System.Threading.CancellationToken cancellationToken) { } + public static System.Threading.Tasks.Task ForEachAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func action, System.Threading.CancellationToken cancellationToken) { } + public static System.Collections.Generic.IAsyncEnumerable> GroupBy(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector) { } + public static System.Collections.Generic.IAsyncEnumerable> GroupBy(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable> GroupBy(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Func elementSelector) { } + public static System.Collections.Generic.IAsyncEnumerable GroupBy(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Func, TResult> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable> GroupBy(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Func elementSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable GroupBy(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Func, TResult> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable GroupBy(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Func elementSelector, System.Func, TResult> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable GroupBy(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Func elementSelector, System.Func, TResult> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable> GroupByAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector) { } + public static System.Collections.Generic.IAsyncEnumerable> GroupByAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable> GroupByAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector) { } + public static System.Collections.Generic.IAsyncEnumerable GroupByAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func, System.Threading.Tasks.ValueTask> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable> GroupByAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable GroupByAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func, System.Threading.Tasks.ValueTask> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable GroupByAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Func, System.Threading.Tasks.ValueTask> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable GroupByAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Func, System.Threading.Tasks.ValueTask> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable> GroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector) { } + public static System.Collections.Generic.IAsyncEnumerable> GroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable> GroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector) { } + public static System.Collections.Generic.IAsyncEnumerable GroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable> GroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable GroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable GroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Func, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable GroupByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Func, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable GroupJoin(this System.Collections.Generic.IAsyncEnumerable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Func outerKeySelector, System.Func innerKeySelector, System.Func, TResult> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable GroupJoin(this System.Collections.Generic.IAsyncEnumerable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Func outerKeySelector, System.Func innerKeySelector, System.Func, TResult> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable GroupJoinAwait(this System.Collections.Generic.IAsyncEnumerable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Func> outerKeySelector, System.Func> innerKeySelector, System.Func, System.Threading.Tasks.ValueTask> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable GroupJoinAwait(this System.Collections.Generic.IAsyncEnumerable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Func> outerKeySelector, System.Func> innerKeySelector, System.Func, System.Threading.Tasks.ValueTask> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable GroupJoinAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Func> outerKeySelector, System.Func> innerKeySelector, System.Func, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable GroupJoinAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Func> outerKeySelector, System.Func> innerKeySelector, System.Func, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable Intersect(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Collections.Generic.IAsyncEnumerable Intersect(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable Join(this System.Collections.Generic.IAsyncEnumerable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Func outerKeySelector, System.Func innerKeySelector, System.Func resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable Join(this System.Collections.Generic.IAsyncEnumerable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Func outerKeySelector, System.Func innerKeySelector, System.Func resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable JoinAwait(this System.Collections.Generic.IAsyncEnumerable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Func> outerKeySelector, System.Func> innerKeySelector, System.Func> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable JoinAwait(this System.Collections.Generic.IAsyncEnumerable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Func> outerKeySelector, System.Func> innerKeySelector, System.Func> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable JoinAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Func> outerKeySelector, System.Func> innerKeySelector, System.Func> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable JoinAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Func> outerKeySelector, System.Func> innerKeySelector, System.Func> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Threading.Tasks.ValueTask LastAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastOrDefaultAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastOrDefaultAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastOrDefaultAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastOrDefaultAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LongCountAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LongCountAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LongCountAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LongCountAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Collections.Generic.IAsyncEnumerable OfType(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Linq.IOrderedAsyncEnumerable OrderBy(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector) { } + public static System.Linq.IOrderedAsyncEnumerable OrderBy(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Linq.IOrderedAsyncEnumerable OrderByAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector) { } + public static System.Linq.IOrderedAsyncEnumerable OrderByAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Linq.IOrderedAsyncEnumerable OrderByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector) { } + public static System.Linq.IOrderedAsyncEnumerable OrderByAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Linq.IOrderedAsyncEnumerable OrderByDescending(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector) { } + public static System.Linq.IOrderedAsyncEnumerable OrderByDescending(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Linq.IOrderedAsyncEnumerable OrderByDescendingAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector) { } + public static System.Linq.IOrderedAsyncEnumerable OrderByDescendingAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Linq.IOrderedAsyncEnumerable OrderByDescendingAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector) { } + public static System.Linq.IOrderedAsyncEnumerable OrderByDescendingAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Collections.Generic.IAsyncEnumerable Prepend(this System.Collections.Generic.IAsyncEnumerable source, TSource element) { } + public static System.Collections.Generic.IAsyncEnumerable Range(int start, int count) { } + public static System.Collections.Generic.IAsyncEnumerable Repeat(TResult element, int count) { } + public static System.Collections.Generic.IAsyncEnumerable Reverse(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Collections.Generic.IAsyncEnumerable Select(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector) { } + public static System.Collections.Generic.IAsyncEnumerable Select(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectMany(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectMany(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectMany(this System.Collections.Generic.IAsyncEnumerable source, System.Func> collectionSelector, System.Func resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectMany(this System.Collections.Generic.IAsyncEnumerable source, System.Func> collectionSelector, System.Func resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectManyAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func>> selector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectManyAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func>> selector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectManyAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func>> collectionSelector, System.Func> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectManyAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func>> collectionSelector, System.Func> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectManyAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func>> selector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectManyAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func>> selector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectManyAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func>> collectionSelector, System.Func> resultSelector) { } + public static System.Collections.Generic.IAsyncEnumerable SelectManyAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func>> collectionSelector, System.Func> resultSelector) { } + public static System.Threading.Tasks.ValueTask SequenceEqualAsync(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SequenceEqualAsync(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleOrDefaultAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleOrDefaultAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleOrDefaultAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleOrDefaultAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Collections.Generic.IAsyncEnumerable Skip(this System.Collections.Generic.IAsyncEnumerable source, int count) { } + public static System.Collections.Generic.IAsyncEnumerable SkipLast(this System.Collections.Generic.IAsyncEnumerable source, int count) { } + public static System.Collections.Generic.IAsyncEnumerable SkipWhile(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate) { } + public static System.Collections.Generic.IAsyncEnumerable SkipWhile(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate) { } + public static System.Collections.Generic.IAsyncEnumerable SkipWhileAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate) { } + public static System.Collections.Generic.IAsyncEnumerable SkipWhileAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate) { } + public static System.Collections.Generic.IAsyncEnumerable SkipWhileAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate) { } + public static System.Collections.Generic.IAsyncEnumerable SkipWhileAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Collections.Generic.IAsyncEnumerable Take(this System.Collections.Generic.IAsyncEnumerable source, int count) { } + public static System.Collections.Generic.IAsyncEnumerable TakeLast(this System.Collections.Generic.IAsyncEnumerable source, int count) { } + public static System.Collections.Generic.IAsyncEnumerable TakeWhile(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate) { } + public static System.Collections.Generic.IAsyncEnumerable TakeWhile(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate) { } + public static System.Collections.Generic.IAsyncEnumerable TakeWhileAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate) { } + public static System.Collections.Generic.IAsyncEnumerable TakeWhileAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate) { } + public static System.Collections.Generic.IAsyncEnumerable TakeWhileAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate) { } + public static System.Collections.Generic.IAsyncEnumerable TakeWhileAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate) { } + public static System.Linq.IOrderedAsyncEnumerable ThenBy(this System.Linq.IOrderedAsyncEnumerable source, System.Func keySelector) { } + public static System.Linq.IOrderedAsyncEnumerable ThenBy(this System.Linq.IOrderedAsyncEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Linq.IOrderedAsyncEnumerable ThenByAwait(this System.Linq.IOrderedAsyncEnumerable source, System.Func> keySelector) { } + public static System.Linq.IOrderedAsyncEnumerable ThenByAwait(this System.Linq.IOrderedAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Linq.IOrderedAsyncEnumerable ThenByAwaitWithCancellation(this System.Linq.IOrderedAsyncEnumerable source, System.Func> keySelector) { } + public static System.Linq.IOrderedAsyncEnumerable ThenByAwaitWithCancellation(this System.Linq.IOrderedAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Linq.IOrderedAsyncEnumerable ThenByDescending(this System.Linq.IOrderedAsyncEnumerable source, System.Func keySelector) { } + public static System.Linq.IOrderedAsyncEnumerable ThenByDescending(this System.Linq.IOrderedAsyncEnumerable source, System.Func keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Linq.IOrderedAsyncEnumerable ThenByDescendingAwait(this System.Linq.IOrderedAsyncEnumerable source, System.Func> keySelector) { } + public static System.Linq.IOrderedAsyncEnumerable ThenByDescendingAwait(this System.Linq.IOrderedAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Linq.IOrderedAsyncEnumerable ThenByDescendingAwaitWithCancellation(this System.Linq.IOrderedAsyncEnumerable source, System.Func> keySelector) { } + public static System.Linq.IOrderedAsyncEnumerable ThenByDescendingAwaitWithCancellation(this System.Linq.IOrderedAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IComparer comparer) { } + public static System.Threading.Tasks.ValueTask ToArrayAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Collections.Generic.IAsyncEnumerable ToAsyncEnumerable(this System.Collections.Generic.IEnumerable source) { } + public static System.Collections.Generic.IAsyncEnumerable ToAsyncEnumerable(this System.IObservable source) { } + public static System.Collections.Generic.IAsyncEnumerable ToAsyncEnumerable(this System.Threading.Tasks.Task task) { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Func elementSelector, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Func elementSelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Collections.Generic.IEnumerable ToEnumerable(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Threading.Tasks.ValueTask> ToHashSetAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToHashSetAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToListAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Func elementSelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func keySelector, System.Func elementSelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitWithCancellationAsync(this System.Collections.Generic.IAsyncEnumerable source, System.Func> keySelector, System.Func> elementSelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.IObservable ToObservable(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Collections.Generic.IAsyncEnumerable Union(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Collections.Generic.IAsyncEnumerable Union(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Collections.Generic.IAsyncEnumerable Where(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate) { } + public static System.Collections.Generic.IAsyncEnumerable Where(this System.Collections.Generic.IAsyncEnumerable source, System.Func predicate) { } + public static System.Collections.Generic.IAsyncEnumerable WhereAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate) { } + public static System.Collections.Generic.IAsyncEnumerable WhereAwait(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate) { } + public static System.Collections.Generic.IAsyncEnumerable WhereAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate) { } + public static System.Collections.Generic.IAsyncEnumerable WhereAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable source, System.Func> predicate) { } + [return: System.Runtime.CompilerServices.TupleElementNames(new string[] { + "First", + "Second"})] + public static System.Collections.Generic.IAsyncEnumerable> Zip(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Collections.Generic.IAsyncEnumerable Zip(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second, System.Func selector) { } + public static System.Collections.Generic.IAsyncEnumerable ZipAwait(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second, System.Func> selector) { } + public static System.Collections.Generic.IAsyncEnumerable ZipAwaitWithCancellation(this System.Collections.Generic.IAsyncEnumerable first, System.Collections.Generic.IAsyncEnumerable second, System.Func> selector) { } + } + public interface IAsyncGrouping : System.Collections.Generic.IAsyncEnumerable + { + TKey Key { get; } + } + public interface IAsyncIListProvider : System.Collections.Generic.IAsyncEnumerable + { + System.Threading.Tasks.ValueTask GetCountAsync(bool onlyIfCheap, System.Threading.CancellationToken cancellationToken); + System.Threading.Tasks.ValueTask ToArrayAsync(System.Threading.CancellationToken cancellationToken); + System.Threading.Tasks.ValueTask> ToListAsync(System.Threading.CancellationToken cancellationToken); + } + public interface IOrderedAsyncEnumerable : System.Collections.Generic.IAsyncEnumerable + { + System.Linq.IOrderedAsyncEnumerable CreateOrderedEnumerable(System.Func> keySelector, System.Collections.Generic.IComparer? comparer, bool descending); + System.Linq.IOrderedAsyncEnumerable CreateOrderedEnumerable(System.Func keySelector, System.Collections.Generic.IComparer? comparer, bool descending); + System.Linq.IOrderedAsyncEnumerable CreateOrderedEnumerable(System.Func> keySelector, System.Collections.Generic.IComparer? comparer, bool descending); + } +} \ No newline at end of file diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.verified.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.verified.cs new file mode 100644 index 0000000000..ef82c6d2c9 --- /dev/null +++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.SystemLinqAsyncQueryable.verified.cs @@ -0,0 +1,413 @@ +[assembly: System.CLSCompliant(true)] +[assembly: System.Resources.NeutralResourcesLanguage("en-US")] +[assembly: System.Runtime.InteropServices.ComVisible(false)] +[assembly: System.Runtime.Versioning.TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName=".NET 6.0")] +namespace System.Linq +{ + public static class AsyncQueryable + { + public static System.Threading.Tasks.ValueTask AggregateAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> accumulator, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAsync(this System.Linq.IAsyncQueryable source, TAccumulate seed, System.Linq.Expressions.Expression> accumulator, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAsync(this System.Linq.IAsyncQueryable source, TAccumulate seed, System.Linq.Expressions.Expression> accumulator, System.Linq.Expressions.Expression> resultSelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> accumulator, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAwaitAsync(this System.Linq.IAsyncQueryable source, TAccumulate seed, System.Linq.Expressions.Expression>> accumulator, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAwaitAsync(this System.Linq.IAsyncQueryable source, TAccumulate seed, System.Linq.Expressions.Expression>> accumulator, System.Linq.Expressions.Expression>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> accumulator, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, TAccumulate seed, System.Linq.Expressions.Expression>> accumulator, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AggregateAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, TAccumulate seed, System.Linq.Expressions.Expression>> accumulator, System.Linq.Expressions.Expression>> resultSelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AllAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AllAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AllAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AnyAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AnyAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AnyAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AnyAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Linq.IAsyncQueryable Append(this System.Linq.IAsyncQueryable source, TSource element) { } + public static System.Linq.IAsyncQueryable AsAsyncQueryable(this System.Collections.Generic.IAsyncEnumerable source) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask AverageAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Linq.IAsyncQueryable Cast(this System.Linq.IAsyncQueryable source) { } + public static System.Linq.IAsyncQueryable Concat(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Threading.Tasks.ValueTask ContainsAsync(this System.Linq.IAsyncQueryable source, TSource value, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask ContainsAsync(this System.Linq.IAsyncQueryable source, TSource value, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask CountAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask CountAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask CountAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask CountAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Linq.IAsyncQueryable DefaultIfEmpty(this System.Linq.IAsyncQueryable source) { } + public static System.Linq.IAsyncQueryable DefaultIfEmpty(this System.Linq.IAsyncQueryable source, TSource defaultValue) { } + public static System.Linq.IAsyncQueryable Distinct(this System.Linq.IAsyncQueryable source) { } + public static System.Linq.IAsyncQueryable Distinct(this System.Linq.IAsyncQueryable source, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Threading.Tasks.ValueTask ElementAtAsync(this System.Linq.IAsyncQueryable source, int index, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask ElementAtOrDefaultAsync(this System.Linq.IAsyncQueryable source, int index, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Linq.IAsyncQueryable Except(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Linq.IAsyncQueryable Except(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Threading.Tasks.ValueTask FirstAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstOrDefaultAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstOrDefaultAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstOrDefaultAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask FirstOrDefaultAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Linq.IAsyncQueryable> GroupBy(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Linq.IAsyncQueryable> GroupBy(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable> GroupBy(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector) { } + public static System.Linq.IAsyncQueryable GroupBy(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression, TResult>> resultSelector) { } + public static System.Linq.IAsyncQueryable> GroupBy(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable GroupBy(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable GroupBy(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Linq.Expressions.Expression, TResult>> resultSelector) { } + public static System.Linq.IAsyncQueryable GroupBy(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Linq.Expressions.Expression, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable> GroupByAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IAsyncQueryable> GroupByAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable> GroupByAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector) { } + public static System.Linq.IAsyncQueryable GroupByAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression, System.Threading.Tasks.ValueTask>> resultSelector) { } + public static System.Linq.IAsyncQueryable> GroupByAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable GroupByAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression, System.Threading.Tasks.ValueTask>> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable GroupByAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Linq.Expressions.Expression, System.Threading.Tasks.ValueTask>> resultSelector) { } + public static System.Linq.IAsyncQueryable GroupByAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Linq.Expressions.Expression, System.Threading.Tasks.ValueTask>> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable> GroupByAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IAsyncQueryable> GroupByAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable> GroupByAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector) { } + public static System.Linq.IAsyncQueryable GroupByAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>> resultSelector) { } + public static System.Linq.IAsyncQueryable> GroupByAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable GroupByAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable GroupByAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Linq.Expressions.Expression, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>> resultSelector) { } + public static System.Linq.IAsyncQueryable GroupByAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Linq.Expressions.Expression, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable GroupJoin(this System.Linq.IAsyncQueryable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Linq.Expressions.Expression> outerKeySelector, System.Linq.Expressions.Expression> innerKeySelector, System.Linq.Expressions.Expression, TResult>> resultSelector) { } + public static System.Linq.IAsyncQueryable GroupJoin(this System.Linq.IAsyncQueryable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Linq.Expressions.Expression> outerKeySelector, System.Linq.Expressions.Expression> innerKeySelector, System.Linq.Expressions.Expression, TResult>> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable GroupJoinAwait(this System.Linq.IAsyncQueryable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Linq.Expressions.Expression>> outerKeySelector, System.Linq.Expressions.Expression>> innerKeySelector, System.Linq.Expressions.Expression, System.Threading.Tasks.ValueTask>> resultSelector) { } + public static System.Linq.IAsyncQueryable GroupJoinAwait(this System.Linq.IAsyncQueryable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Linq.Expressions.Expression>> outerKeySelector, System.Linq.Expressions.Expression>> innerKeySelector, System.Linq.Expressions.Expression, System.Threading.Tasks.ValueTask>> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable GroupJoinAwaitWithCancellation(this System.Linq.IAsyncQueryable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Linq.Expressions.Expression>> outerKeySelector, System.Linq.Expressions.Expression>> innerKeySelector, System.Linq.Expressions.Expression, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>> resultSelector) { } + public static System.Linq.IAsyncQueryable GroupJoinAwaitWithCancellation(this System.Linq.IAsyncQueryable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Linq.Expressions.Expression>> outerKeySelector, System.Linq.Expressions.Expression>> innerKeySelector, System.Linq.Expressions.Expression, System.Threading.CancellationToken, System.Threading.Tasks.ValueTask>> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable Intersect(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Linq.IAsyncQueryable Intersect(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable Join(this System.Linq.IAsyncQueryable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Linq.Expressions.Expression> outerKeySelector, System.Linq.Expressions.Expression> innerKeySelector, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Linq.IAsyncQueryable Join(this System.Linq.IAsyncQueryable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Linq.Expressions.Expression> outerKeySelector, System.Linq.Expressions.Expression> innerKeySelector, System.Linq.Expressions.Expression> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable JoinAwait(this System.Linq.IAsyncQueryable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Linq.Expressions.Expression>> outerKeySelector, System.Linq.Expressions.Expression>> innerKeySelector, System.Linq.Expressions.Expression>> resultSelector) { } + public static System.Linq.IAsyncQueryable JoinAwait(this System.Linq.IAsyncQueryable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Linq.Expressions.Expression>> outerKeySelector, System.Linq.Expressions.Expression>> innerKeySelector, System.Linq.Expressions.Expression>> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable JoinAwaitWithCancellation(this System.Linq.IAsyncQueryable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Linq.Expressions.Expression>> outerKeySelector, System.Linq.Expressions.Expression>> innerKeySelector, System.Linq.Expressions.Expression>> resultSelector) { } + public static System.Linq.IAsyncQueryable JoinAwaitWithCancellation(this System.Linq.IAsyncQueryable outer, System.Collections.Generic.IAsyncEnumerable inner, System.Linq.Expressions.Expression>> outerKeySelector, System.Linq.Expressions.Expression>> innerKeySelector, System.Linq.Expressions.Expression>> resultSelector, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Threading.Tasks.ValueTask LastAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastOrDefaultAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastOrDefaultAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastOrDefaultAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LastOrDefaultAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LongCountAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LongCountAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LongCountAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask LongCountAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MaxAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask MinAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Linq.IAsyncQueryable OfType(this System.Linq.IAsyncQueryable source) { } + public static System.Linq.IOrderedAsyncQueryable OrderBy(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Linq.IOrderedAsyncQueryable OrderBy(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IComparer? comparer) { } + public static System.Linq.IOrderedAsyncQueryable OrderByAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IOrderedAsyncQueryable OrderByAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IComparer? comparer) { } + public static System.Linq.IOrderedAsyncQueryable OrderByAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IOrderedAsyncQueryable OrderByAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IComparer? comparer) { } + public static System.Linq.IOrderedAsyncQueryable OrderByDescending(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Linq.IOrderedAsyncQueryable OrderByDescending(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IComparer? comparer) { } + public static System.Linq.IOrderedAsyncQueryable OrderByDescendingAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IOrderedAsyncQueryable OrderByDescendingAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IComparer? comparer) { } + public static System.Linq.IOrderedAsyncQueryable OrderByDescendingAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IOrderedAsyncQueryable OrderByDescendingAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IComparer? comparer) { } + public static System.Linq.IAsyncQueryable Prepend(this System.Linq.IAsyncQueryable source, TSource element) { } + public static System.Linq.IAsyncQueryable Reverse(this System.Linq.IAsyncQueryable source) { } + public static System.Linq.IAsyncQueryable Select(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector) { } + public static System.Linq.IAsyncQueryable Select(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector) { } + public static System.Linq.IAsyncQueryable SelectAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Linq.IAsyncQueryable SelectAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Linq.IAsyncQueryable SelectAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Linq.IAsyncQueryable SelectAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Linq.IAsyncQueryable SelectMany(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Linq.IAsyncQueryable SelectMany(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector) { } + public static System.Linq.IAsyncQueryable SelectMany(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> collectionSelector, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Linq.IAsyncQueryable SelectMany(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> collectionSelector, System.Linq.Expressions.Expression> resultSelector) { } + public static System.Linq.IAsyncQueryable SelectManyAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>>> selector) { } + public static System.Linq.IAsyncQueryable SelectManyAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>>> selector) { } + public static System.Linq.IAsyncQueryable SelectManyAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>>> collectionSelector, System.Linq.Expressions.Expression>> resultSelector) { } + public static System.Linq.IAsyncQueryable SelectManyAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>>> collectionSelector, System.Linq.Expressions.Expression>> resultSelector) { } + public static System.Linq.IAsyncQueryable SelectManyAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>>> selector) { } + public static System.Linq.IAsyncQueryable SelectManyAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>>> selector) { } + public static System.Linq.IAsyncQueryable SelectManyAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>>> collectionSelector, System.Linq.Expressions.Expression>> resultSelector) { } + public static System.Linq.IAsyncQueryable SelectManyAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>>> collectionSelector, System.Linq.Expressions.Expression>> resultSelector) { } + public static System.Threading.Tasks.ValueTask SequenceEqualAsync(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SequenceEqualAsync(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleOrDefaultAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleOrDefaultAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleOrDefaultAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SingleOrDefaultAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Linq.IAsyncQueryable Skip(this System.Linq.IAsyncQueryable source, int count) { } + public static System.Linq.IAsyncQueryable SkipLast(this System.Linq.IAsyncQueryable source, int count) { } + public static System.Linq.IAsyncQueryable SkipWhile(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Linq.IAsyncQueryable SkipWhile(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Linq.IAsyncQueryable SkipWhileAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate) { } + public static System.Linq.IAsyncQueryable SkipWhileAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate) { } + public static System.Linq.IAsyncQueryable SkipWhileAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate) { } + public static System.Linq.IAsyncQueryable SkipWhileAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask SumAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> selector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Linq.IAsyncQueryable Take(this System.Linq.IAsyncQueryable source, int count) { } + public static System.Linq.IAsyncQueryable TakeLast(this System.Linq.IAsyncQueryable source, int count) { } + public static System.Linq.IAsyncQueryable TakeWhile(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Linq.IAsyncQueryable TakeWhile(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Linq.IAsyncQueryable TakeWhileAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate) { } + public static System.Linq.IAsyncQueryable TakeWhileAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate) { } + public static System.Linq.IAsyncQueryable TakeWhileAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate) { } + public static System.Linq.IAsyncQueryable TakeWhileAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate) { } + public static System.Linq.IOrderedAsyncQueryable ThenBy(this System.Linq.IOrderedAsyncQueryable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Linq.IOrderedAsyncQueryable ThenBy(this System.Linq.IOrderedAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IComparer? comparer) { } + public static System.Linq.IOrderedAsyncQueryable ThenByAwait(this System.Linq.IOrderedAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IOrderedAsyncQueryable ThenByAwait(this System.Linq.IOrderedAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IComparer? comparer) { } + public static System.Linq.IOrderedAsyncQueryable ThenByAwaitWithCancellation(this System.Linq.IOrderedAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IOrderedAsyncQueryable ThenByAwaitWithCancellation(this System.Linq.IOrderedAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IComparer? comparer) { } + public static System.Linq.IOrderedAsyncQueryable ThenByDescending(this System.Linq.IOrderedAsyncQueryable source, System.Linq.Expressions.Expression> keySelector) { } + public static System.Linq.IOrderedAsyncQueryable ThenByDescending(this System.Linq.IOrderedAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IComparer? comparer) { } + public static System.Linq.IOrderedAsyncQueryable ThenByDescendingAwait(this System.Linq.IOrderedAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IOrderedAsyncQueryable ThenByDescendingAwait(this System.Linq.IOrderedAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IComparer? comparer) { } + public static System.Linq.IOrderedAsyncQueryable ThenByDescendingAwaitWithCancellation(this System.Linq.IOrderedAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector) { } + public static System.Linq.IOrderedAsyncQueryable ThenByDescendingAwaitWithCancellation(this System.Linq.IOrderedAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IComparer? comparer) { } + public static System.Threading.Tasks.ValueTask ToArrayAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToDictionaryAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) + where TKey : notnull { } + public static System.Threading.Tasks.ValueTask> ToHashSetAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToHashSetAsync(this System.Linq.IAsyncQueryable source, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToListAsync(this System.Linq.IAsyncQueryable source, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> keySelector, System.Linq.Expressions.Expression> elementSelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Threading.Tasks.ValueTask> ToLookupAwaitWithCancellationAsync(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> keySelector, System.Linq.Expressions.Expression>> elementSelector, System.Collections.Generic.IEqualityComparer? comparer, System.Threading.CancellationToken cancellationToken = default) { } + public static System.Linq.IAsyncQueryable Union(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Linq.IAsyncQueryable Union(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second, System.Collections.Generic.IEqualityComparer? comparer) { } + public static System.Linq.IAsyncQueryable Where(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Linq.IAsyncQueryable Where(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression> predicate) { } + public static System.Linq.IAsyncQueryable WhereAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate) { } + public static System.Linq.IAsyncQueryable WhereAwait(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate) { } + public static System.Linq.IAsyncQueryable WhereAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate) { } + public static System.Linq.IAsyncQueryable WhereAwaitWithCancellation(this System.Linq.IAsyncQueryable source, System.Linq.Expressions.Expression>> predicate) { } + public static System.Linq.IAsyncQueryable> Zip(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second) { } + public static System.Linq.IAsyncQueryable Zip(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second, System.Linq.Expressions.Expression> selector) { } + public static System.Linq.IAsyncQueryable ZipAwait(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second, System.Linq.Expressions.Expression>> selector) { } + public static System.Linq.IAsyncQueryable ZipAwaitWithCancellation(this System.Linq.IAsyncQueryable first, System.Collections.Generic.IAsyncEnumerable second, System.Linq.Expressions.Expression>> selector) { } + } + public interface IAsyncQueryProvider + { + System.Linq.IAsyncQueryable CreateQuery(System.Linq.Expressions.Expression expression); + System.Threading.Tasks.ValueTask ExecuteAsync(System.Linq.Expressions.Expression expression, System.Threading.CancellationToken token); + } + public interface IAsyncQueryable + { + System.Type ElementType { get; } + System.Linq.Expressions.Expression Expression { get; } + System.Linq.IAsyncQueryProvider Provider { get; } + } + public interface IAsyncQueryable : System.Collections.Generic.IAsyncEnumerable, System.Linq.IAsyncQueryable { } + public interface IOrderedAsyncQueryable : System.Linq.IAsyncQueryable { } + public interface IOrderedAsyncQueryable : System.Collections.Generic.IAsyncEnumerable, System.Linq.IAsyncQueryable, System.Linq.IAsyncQueryable, System.Linq.IOrderedAsyncQueryable { } + [System.AttributeUsage(System.AttributeTargets.Class, AllowMultiple=false, Inherited=false)] + public sealed class LocalQueryMethodImplementationTypeAttribute : System.Attribute + { + public LocalQueryMethodImplementationTypeAttribute(System.Type targetType) { } + public System.Type TargetType { get; } + } +} \ No newline at end of file diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.cs new file mode 100644 index 0000000000..a74e511331 --- /dev/null +++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Api/ApiApprovalTests.cs @@ -0,0 +1,95 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT License. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; + +using PublicApiGenerator; + +using VerifyXunit; + +namespace Tests.System.Interactive.ApiApprovals.Api; + +public class ApiApprovalTests : VerifyBase +{ + static ApiApprovalTests() + { + VerifierSettings.OnVerifyMismatch((filePair, message, autoVerify) => DiffPlexReporter.Report(filePair.ReceivedPath, filePair.VerifiedPath, message)); + } + + public ApiApprovalTests() + : base() + { + } + + [Fact] + public Task SystemInteractive() + { + var publicApi = GeneratePublicApi(typeof(EnumerableEx).Assembly); + return Verify(publicApi, "cs"); + } + + [Fact] + public Task SystemInteractiveProviders() + { + var publicApi = GeneratePublicApi(typeof(QueryableEx).Assembly); + return Verify(publicApi, "cs"); + } + + [Fact] + public Task SystemInteractiveAsync() + { + var publicApi = GeneratePublicApi(typeof(AsyncEnumerableEx).Assembly); + return Verify(publicApi, "cs"); + } + + [Fact] + public Task SystemInteractiveAsyncProviders() + { + var publicApi = GeneratePublicApi(typeof(AsyncQueryableEx).Assembly); + return Verify(publicApi, "cs"); + } + + [Fact] + public Task SystemLinqAsync() + { + var publicApi = GeneratePublicApi(typeof(AsyncEnumerable).Assembly); + return Verify(publicApi, "cs"); + } + + [Fact] + public Task SystemLinqAsyncQueryable() + { + var publicApi = GeneratePublicApi(typeof(AsyncQueryable).Assembly); + return Verify(publicApi, "cs"); + } + + private string GeneratePublicApi(Assembly assembly) + { + ApiGeneratorOptions options = new() + { + AllowNamespacePrefixes = ["System", "Microsoft"] + }; + return Filter(ApiGenerator.GeneratePublicApi(assembly, options)); + } + + private static string Filter(string text) + { + return string.Join(Environment.NewLine, text.Split(new[] + { + Environment.NewLine + }, StringSplitOptions.RemoveEmptyEntries) + .Where(l => !l.StartsWith("[assembly: AssemblyVersion(")) + .Where(l => !l.StartsWith("[assembly: AssemblyFileVersion(")) + .Where(l => !l.StartsWith("[assembly: AssemblyInformationalVersion(")) + .Where(l => !l.StartsWith("[assembly: System.Reflection.AssemblyMetadata(\"CommitHash\"")) + .Where(l => !l.StartsWith("[assembly: System.Reflection.AssemblyMetadata(\"RepositoryUrl\"")) + .Where(l => !string.IsNullOrWhiteSpace(l)) + ); + } +} diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/DiffPlexReporter.cs b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/DiffPlexReporter.cs new file mode 100644 index 0000000000..d4b0e4f647 --- /dev/null +++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/DiffPlexReporter.cs @@ -0,0 +1,38 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT License. +// See the LICENSE file in the project root for more information. + +namespace Tests.System.Interactive.ApiApprovals; + +internal static class DiffPlexReporter +{ + public static Task Report(string receivedFile, string verifiedFile, string? message) + { +#if (!DEBUG) + var receivedText = File.ReadAllText(receivedFile); + var verifiedText = File.ReadAllText(verifiedFile); + var diffBuilder = new InlineDiffBuilder(new Differ()); + var diff = diffBuilder.BuildDiffModel(verifiedText, receivedText); + + foreach (var line in diff.Lines) + { + if (line.Type == ChangeType.Unchanged) continue; + + var prefix = " "; + switch (line.Type) + { + case ChangeType.Inserted: + prefix = "+ "; + break; + case ChangeType.Deleted: + prefix = "- "; + break; + } + + Console.WriteLine("{0}{1}", prefix, line.Text); + } +#endif + + return Task.CompletedTask; + } +} diff --git a/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Tests.System.Interactive.ApiApprovals.csproj b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Tests.System.Interactive.ApiApprovals.csproj new file mode 100644 index 0000000000..a6022437c3 --- /dev/null +++ b/Ix.NET/Source/Tests.System.Interactive.ApiApprovals/Tests.System.Interactive.ApiApprovals.csproj @@ -0,0 +1,43 @@ + + + + net8.0 + enable + enable + + false + true + + + + + + + + + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + + + + + + + + + diff --git a/Ix.NET/Source/global.json b/Ix.NET/Source/global.json deleted file mode 100644 index 0385fde5c2..0000000000 --- a/Ix.NET/Source/global.json +++ /dev/null @@ -1,5 +0,0 @@ -{ - "msbuild-sdks": { - "MSBuild.Sdk.Extras": "3.0.44" - } -} diff --git a/Ix.NET/Source/refs/System.Interactive.Providers.Ref/System.Interactive.Providers.csproj b/Ix.NET/Source/refs/System.Interactive.Providers/System.Interactive.Providers.csproj similarity index 55% rename from Ix.NET/Source/refs/System.Interactive.Providers.Ref/System.Interactive.Providers.csproj rename to Ix.NET/Source/refs/System.Interactive.Providers/System.Interactive.Providers.csproj index 6958af7df7..d31936f4bc 100644 --- a/Ix.NET/Source/refs/System.Interactive.Providers.Ref/System.Interactive.Providers.csproj +++ b/Ix.NET/Source/refs/System.Interactive.Providers/System.Interactive.Providers.csproj @@ -1,14 +1,22 @@ - + + true + Interactive Extensions Providers Library used to build query providers and express queries over enumerable sequences. Interactive Extensions - Providers Library - net4.8;netstandard2.1;net6.0 + + + net48;netstandard2.1;net6.0 Ix;Interactive;Extensions;Enumerable - + diff --git a/Ix.NET/Source/refs/System.Interactive.Ref/System.Interactive.csproj b/Ix.NET/Source/refs/System.Interactive/System.Interactive.csproj similarity index 58% rename from Ix.NET/Source/refs/System.Interactive.Ref/System.Interactive.csproj rename to Ix.NET/Source/refs/System.Interactive/System.Interactive.csproj index 598c60f3b7..47d0858a48 100644 --- a/Ix.NET/Source/refs/System.Interactive.Ref/System.Interactive.csproj +++ b/Ix.NET/Source/refs/System.Interactive/System.Interactive.csproj @@ -1,10 +1,18 @@ - + + true + Interactive Extensions Main Library used to express queries over enumerable sequences. Interactive Extensions - Main Library Microsoft - net4.8;netstandard2.1;net6.0 + + + net48;netstandard2.1;net6.0 Ix;Interactive;Extensions;Enumerable diff --git a/Ix.NET/Source/refs/System.Linq.Async.Ref/System.Linq.Async.csproj b/Ix.NET/Source/refs/System.Linq.Async.Ref/System.Linq.Async.csproj deleted file mode 100644 index 231da05917..0000000000 --- a/Ix.NET/Source/refs/System.Linq.Async.Ref/System.Linq.Async.csproj +++ /dev/null @@ -1,27 +0,0 @@ - - - - LINQ Standard Query Operators used to express queries over asynchronous enumerable sequences. - System.Linq.Async - Microsoft - net48;netstandard2.0;netstandard2.1;net6.0 - Enumerable;Asynchronous;LINQ - System.Linq.Async - - - - - - - - ExtrasIsReferenceAssembly;AssemblyName;Version;AssemblyTitle - - - - - - - - diff --git a/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj b/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj new file mode 100644 index 0000000000..c2de741b94 --- /dev/null +++ b/Ix.NET/Source/refs/System.Linq.Async/System.Linq.Async.csproj @@ -0,0 +1,35 @@ + + + + true + + LINQ Standard Query Operators used to express queries over asynchronous enumerable sequences. + System.Linq.Async + Microsoft + net48;netstandard2.0;netstandard2.1;net6.0 + Enumerable;Asynchronous;LINQ + System.Linq.Async + + + + + $(NoWarn);IDE0301;IDE0305 + + + + + + + + + + + + + + + + + diff --git a/azure-pipelines.ix.yml b/azure-pipelines.ix.yml index 5aacc1a459..dfff79bab5 100644 --- a/azure-pipelines.ix.yml +++ b/azure-pipelines.ix.yml @@ -64,6 +64,16 @@ stages: projects: Ix.NET/Source/**/*.csproj displayName: Restore + # Since we can no longer use MSBuild.Extras.SDK, the reference assembly projects don't get built automatically + # when the corresponding main project run, so we need this extra build step to ensure that the files exist by + # the time pack runs + - task: DotNetCoreCLI@2 + inputs: + command: build + arguments: -c $(BuildConfiguration) + projects: Ix.NET/Source/refs/**/*.csproj + displayName: Build reference assemblies + - task: DotNetCoreCLI@2 inputs: command: pack