diff options
Diffstat (limited to 'release-notes/7.0/preview/api-diff/rc1/Microsoft.NETCore.App/7.0-rc1_System.Linq.md')
| -rw-r--r-- | release-notes/7.0/preview/api-diff/rc1/Microsoft.NETCore.App/7.0-rc1_System.Linq.md | 423 |
1 files changed, 423 insertions, 0 deletions
diff --git a/release-notes/7.0/preview/api-diff/rc1/Microsoft.NETCore.App/7.0-rc1_System.Linq.md b/release-notes/7.0/preview/api-diff/rc1/Microsoft.NETCore.App/7.0-rc1_System.Linq.md new file mode 100644 index 00000000..cd487370 --- /dev/null +++ b/release-notes/7.0/preview/api-diff/rc1/Microsoft.NETCore.App/7.0-rc1_System.Linq.md @@ -0,0 +1,423 @@ +# System.Linq + +``` diff + namespace System.Linq { +- public class EnumerableQuery<T> : EnumerableQuery, IEnumerable, IEnumerable<T>, IOrderedQueryable, IOrderedQueryable<T>, IQueryable, IQueryable<T>, IQueryProvider ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public class EnumerableQuery<T> : EnumerableQuery, IEnumerable, IEnumerable<T>, IOrderedQueryable, IOrderedQueryable<T>, IQueryable, IQueryable<T>, IQueryProvider + public static class Queryable { +- public static TResult Aggregate<TSource, TAccumulate, TResult>(this IQueryable<TSource> source, TAccumulate seed, Expression<Func<TAccumulate, TSource, TAccumulate>> func, Expression<Func<TAccumulate, TResult>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TResult Aggregate<TSource, TAccumulate, TResult>(this IQueryable<TSource> source, TAccumulate seed, Expression<Func<TAccumulate, TSource, TAccumulate>> func, Expression<Func<TAccumulate, TResult>> selector); +- public static TAccumulate Aggregate<TSource, TAccumulate>(this IQueryable<TSource> source, TAccumulate seed, Expression<Func<TAccumulate, TSource, TAccumulate>> func); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TAccumulate Aggregate<TSource, TAccumulate>(this IQueryable<TSource> source, TAccumulate seed, Expression<Func<TAccumulate, TSource, TAccumulate>> func); +- public static TSource Aggregate<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, TSource, TSource>> func); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource Aggregate<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, TSource, TSource>> func); +- public static bool All<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static bool All<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static bool Any<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static bool Any<TSource>(this IQueryable<TSource> source); +- public static bool Any<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static bool Any<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static IQueryable<TSource> Append<TSource>(this IQueryable<TSource> source, TSource element); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Append<TSource>(this IQueryable<TSource> source, TSource element); +- public static IQueryable AsQueryable(this IEnumerable source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable AsQueryable(this IEnumerable source); +- public static IQueryable<TElement> AsQueryable<TElement>(this IEnumerable<TElement> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TElement> AsQueryable<TElement>(this IEnumerable<TElement> source); +- public static decimal Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static decimal Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal>> selector); +- public static double Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static double Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double>> selector); +- public static double Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static double Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int>> selector); +- public static double Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static double Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long>> selector); +- public static decimal? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal?>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static decimal? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal?>> selector); +- public static double? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double?>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static double? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double?>> selector); +- public static double? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int?>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static double? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int?>> selector); +- public static double? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long?>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static double? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long?>> selector); +- public static float? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float?>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static float? Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float?>> selector); +- public static float Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static float Average<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float>> selector); +- public static IQueryable<TResult> Cast<TResult>(this IQueryable source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> Cast<TResult>(this IQueryable source); +- public static IQueryable<TSource[]> Chunk<TSource>(this IQueryable<TSource> source, int size); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource[]> Chunk<TSource>(this IQueryable<TSource> source, int size); +- public static IQueryable<TSource> Concat<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Concat<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2); +- public static bool Contains<TSource>(this IQueryable<TSource> source, TSource item); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static bool Contains<TSource>(this IQueryable<TSource> source, TSource item); +- public static bool Contains<TSource>(this IQueryable<TSource> source, TSource item, IEqualityComparer<TSource>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static bool Contains<TSource>(this IQueryable<TSource> source, TSource item, IEqualityComparer<TSource>? comparer); +- public static int Count<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static int Count<TSource>(this IQueryable<TSource> source); +- public static int Count<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static int Count<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static IQueryable<TSource?> DefaultIfEmpty<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource?> DefaultIfEmpty<TSource>(this IQueryable<TSource> source); +- public static IQueryable<TSource> DefaultIfEmpty<TSource>(this IQueryable<TSource> source, TSource defaultValue); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> DefaultIfEmpty<TSource>(this IQueryable<TSource> source, TSource defaultValue); +- public static IQueryable<TSource> Distinct<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Distinct<TSource>(this IQueryable<TSource> source); +- public static IQueryable<TSource> Distinct<TSource>(this IQueryable<TSource> source, IEqualityComparer<TSource>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Distinct<TSource>(this IQueryable<TSource> source, IEqualityComparer<TSource>? comparer); +- public static IQueryable<TSource> DistinctBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> DistinctBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); +- public static IQueryable<TSource> DistinctBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> DistinctBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer); +- public static TSource ElementAt<TSource>(this IQueryable<TSource> source, Index index); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource ElementAt<TSource>(this IQueryable<TSource> source, Index index); +- public static TSource ElementAt<TSource>(this IQueryable<TSource> source, int index); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource ElementAt<TSource>(this IQueryable<TSource> source, int index); +- public static TSource? ElementAtOrDefault<TSource>(this IQueryable<TSource> source, Index index); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? ElementAtOrDefault<TSource>(this IQueryable<TSource> source, Index index); +- public static TSource? ElementAtOrDefault<TSource>(this IQueryable<TSource> source, int index); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? ElementAtOrDefault<TSource>(this IQueryable<TSource> source, int index); +- public static IQueryable<TSource> Except<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Except<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2); +- public static IQueryable<TSource> Except<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Except<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource>? comparer); +- public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector); +- public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> ExceptBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer); +- public static TSource First<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource First<TSource>(this IQueryable<TSource> source); +- public static TSource First<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource First<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static TSource? FirstOrDefault<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? FirstOrDefault<TSource>(this IQueryable<TSource> source); +- public static TSource? FirstOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? FirstOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static TSource FirstOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate, TSource defaultValue); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource FirstOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate, TSource defaultValue); +- public static TSource FirstOrDefault<TSource>(this IQueryable<TSource> source, TSource defaultValue); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource FirstOrDefault<TSource>(this IQueryable<TSource> source, TSource defaultValue); +- public static IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector, Expression<Func<TKey, IEnumerable<TElement>, TResult>> resultSelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector, Expression<Func<TKey, IEnumerable<TElement>, TResult>> resultSelector); +- public static IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector, Expression<Func<TKey, IEnumerable<TElement>, TResult>> resultSelector, IEqualityComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> GroupBy<TSource, TKey, TElement, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector, Expression<Func<TKey, IEnumerable<TElement>, TResult>> resultSelector, IEqualityComparer<TKey>? comparer); +- public static IQueryable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector); +- public static IQueryable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector, IEqualityComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<IGrouping<TKey, TElement>> GroupBy<TSource, TKey, TElement>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TSource, TElement>> elementSelector, IEqualityComparer<TKey>? comparer); +- public static IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TKey, IEnumerable<TSource>, TResult>> resultSelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TKey, IEnumerable<TSource>, TResult>> resultSelector); +- public static IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TKey, IEnumerable<TSource>, TResult>> resultSelector, IEqualityComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> GroupBy<TSource, TKey, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, Expression<Func<TKey, IEnumerable<TSource>, TResult>> resultSelector, IEqualityComparer<TKey>? comparer); +- public static IQueryable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); +- public static IQueryable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer); +- public static IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, IEnumerable<TInner>, TResult>> resultSelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, IEnumerable<TInner>, TResult>> resultSelector); +- public static IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, IEnumerable<TInner>, TResult>> resultSelector, IEqualityComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> GroupJoin<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, IEnumerable<TInner>, TResult>> resultSelector, IEqualityComparer<TKey>? comparer); +- public static IQueryable<TSource> Intersect<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Intersect<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2); +- public static IQueryable<TSource> Intersect<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Intersect<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource>? comparer); +- public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector); +- public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> IntersectBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TKey> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer); +- public static IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, TInner, TResult>> resultSelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, TInner, TResult>> resultSelector); +- public static IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, TInner, TResult>> resultSelector, IEqualityComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> Join<TOuter, TInner, TKey, TResult>(this IQueryable<TOuter> outer, IEnumerable<TInner> inner, Expression<Func<TOuter, TKey>> outerKeySelector, Expression<Func<TInner, TKey>> innerKeySelector, Expression<Func<TOuter, TInner, TResult>> resultSelector, IEqualityComparer<TKey>? comparer); +- public static TSource Last<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource Last<TSource>(this IQueryable<TSource> source); +- public static TSource Last<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource Last<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static TSource? LastOrDefault<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? LastOrDefault<TSource>(this IQueryable<TSource> source); +- public static TSource? LastOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? LastOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static TSource LastOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate, TSource defaultValue); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource LastOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate, TSource defaultValue); +- public static TSource LastOrDefault<TSource>(this IQueryable<TSource> source, TSource defaultValue); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource LastOrDefault<TSource>(this IQueryable<TSource> source, TSource defaultValue); +- public static long LongCount<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static long LongCount<TSource>(this IQueryable<TSource> source); +- public static long LongCount<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static long LongCount<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static TResult? Max<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TResult? Max<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector); +- public static TSource? Max<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? Max<TSource>(this IQueryable<TSource> source); +- public static TSource? Max<TSource>(this IQueryable<TSource> source, IComparer<TSource>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? Max<TSource>(this IQueryable<TSource> source, IComparer<TSource>? comparer); +- public static TSource? MaxBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? MaxBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); +- public static TSource? MaxBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TSource>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? MaxBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TSource>? comparer); +- public static TResult? Min<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TResult? Min<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector); +- public static TSource? Min<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? Min<TSource>(this IQueryable<TSource> source); +- public static TSource? Min<TSource>(this IQueryable<TSource> source, IComparer<TSource>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? Min<TSource>(this IQueryable<TSource> source, IComparer<TSource>? comparer); +- public static TSource? MinBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? MinBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); +- public static TSource? MinBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TSource>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? MinBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TSource>? comparer); +- public static IQueryable<TResult> OfType<TResult>(this IQueryable source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> OfType<TResult>(this IQueryable source); +- public static IOrderedQueryable<T> Order<T>(this IQueryable<T> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IOrderedQueryable<T> Order<T>(this IQueryable<T> source); +- public static IOrderedQueryable<T> Order<T>(this IQueryable<T> source, IComparer<T> comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IOrderedQueryable<T> Order<T>(this IQueryable<T> source, IComparer<T> comparer); +- public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); +- public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey>? comparer); +- public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); +- public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IOrderedQueryable<TSource> OrderByDescending<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey>? comparer); +- public static IOrderedQueryable<T> OrderDescending<T>(this IQueryable<T> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IOrderedQueryable<T> OrderDescending<T>(this IQueryable<T> source); +- public static IOrderedQueryable<T> OrderDescending<T>(this IQueryable<T> source, IComparer<T> comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IOrderedQueryable<T> OrderDescending<T>(this IQueryable<T> source, IComparer<T> comparer); +- public static IQueryable<TSource> Prepend<TSource>(this IQueryable<TSource> source, TSource element); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Prepend<TSource>(this IQueryable<TSource> source, TSource element); +- public static IQueryable<TSource> Reverse<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Reverse<TSource>(this IQueryable<TSource> source); +- public static IQueryable<TResult> Select<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, int, TResult>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> Select<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, int, TResult>> selector); +- public static IQueryable<TResult> Select<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> Select<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, TResult>> selector); +- public static IQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector); +- public static IQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, int, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> SelectMany<TSource, TCollection, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, int, IEnumerable<TCollection>>> collectionSelector, Expression<Func<TSource, TCollection, TResult>> resultSelector); +- public static IQueryable<TResult> SelectMany<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, IEnumerable<TResult>>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> SelectMany<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, IEnumerable<TResult>>> selector); +- public static IQueryable<TResult> SelectMany<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, int, IEnumerable<TResult>>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> SelectMany<TSource, TResult>(this IQueryable<TSource> source, Expression<Func<TSource, int, IEnumerable<TResult>>> selector); +- public static bool SequenceEqual<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static bool SequenceEqual<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2); +- public static bool SequenceEqual<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static bool SequenceEqual<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource>? comparer); +- public static TSource Single<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource Single<TSource>(this IQueryable<TSource> source); +- public static TSource Single<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource Single<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static TSource? SingleOrDefault<TSource>(this IQueryable<TSource> source); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? SingleOrDefault<TSource>(this IQueryable<TSource> source); +- public static TSource? SingleOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource? SingleOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static TSource SingleOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate, TSource defaultValue); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource SingleOrDefault<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate, TSource defaultValue); +- public static TSource SingleOrDefault<TSource>(this IQueryable<TSource> source, TSource defaultValue); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static TSource SingleOrDefault<TSource>(this IQueryable<TSource> source, TSource defaultValue); +- public static IQueryable<TSource> Skip<TSource>(this IQueryable<TSource> source, int count); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Skip<TSource>(this IQueryable<TSource> source, int count); +- public static IQueryable<TSource> SkipLast<TSource>(this IQueryable<TSource> source, int count); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> SkipLast<TSource>(this IQueryable<TSource> source, int count); +- public static IQueryable<TSource> SkipWhile<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> SkipWhile<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static IQueryable<TSource> SkipWhile<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> SkipWhile<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate); +- public static decimal Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static decimal Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal>> selector); +- public static double Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static double Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double>> selector); +- public static int Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static int Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int>> selector); +- public static long Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static long Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long>> selector); +- public static decimal? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal?>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static decimal? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, decimal?>> selector); +- public static double? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double?>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static double? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, double?>> selector); +- public static int? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int?>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static int? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int?>> selector); +- public static long? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long?>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static long? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, long?>> selector); +- public static float? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float?>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static float? Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float?>> selector); +- public static float Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float>> selector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static float Sum<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, float>> selector); +- public static IQueryable<TSource> Take<TSource>(this IQueryable<TSource> source, int count); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Take<TSource>(this IQueryable<TSource> source, int count); +- public static IQueryable<TSource> Take<TSource>(this IQueryable<TSource> source, Range range); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Take<TSource>(this IQueryable<TSource> source, Range range); +- public static IQueryable<TSource> TakeLast<TSource>(this IQueryable<TSource> source, int count); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> TakeLast<TSource>(this IQueryable<TSource> source, int count); +- public static IQueryable<TSource> TakeWhile<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> TakeWhile<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static IQueryable<TSource> TakeWhile<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> TakeWhile<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate); +- public static IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); +- public static IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IOrderedQueryable<TSource> ThenBy<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey>? comparer); +- public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector); +- public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IOrderedQueryable<TSource> ThenByDescending<TSource, TKey>(this IOrderedQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector, IComparer<TKey>? comparer); +- public static IQueryable<TSource> Union<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Union<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2); +- public static IQueryable<TSource> Union<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Union<TSource>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, IEqualityComparer<TSource>? comparer); +- public static IQueryable<TSource> UnionBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> UnionBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector); +- public static IQueryable<TSource> UnionBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> UnionBy<TSource, TKey>(this IQueryable<TSource> source1, IEnumerable<TSource> source2, Expression<Func<TSource, TKey>> keySelector, IEqualityComparer<TKey>? comparer); +- public static IQueryable<TSource> Where<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Where<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, bool>> predicate); +- public static IQueryable<TSource> Where<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TSource> Where<TSource>(this IQueryable<TSource> source, Expression<Func<TSource, int, bool>> predicate); +- public static IQueryable<TResult> Zip<TFirst, TSecond, TResult>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, Expression<Func<TFirst, TSecond, TResult>> resultSelector); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<TResult> Zip<TFirst, TSecond, TResult>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, Expression<Func<TFirst, TSecond, TResult>> resultSelector); +- public static IQueryable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, IEnumerable<TThird> source3); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2, IEnumerable<TThird> source3); +- public static IQueryable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2); ++ [RequiresDynamicCodeAttribute("Enumerating collections as IQueryable can require creating new generic types or methods, which requires creating code at runtime. This may not work when AOT compiling.")] ++ public static IQueryable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this IQueryable<TFirst> source1, IEnumerable<TSecond> source2); + } + } +``` + |