Merge branch 'master' into tuple-transform-refactoring

# Conflicts:
#	ChangeLog/7.2.2-dev.txt

Author: alex-kulakov

.github/workflows/reusable-storage-dependant-tests.yml

@@ -116,18 +116,20 @@ jobs:
         timeout-minutes: 10
         run: '${{ vars[env.DOCKER_SCRIPT_KEY] }}'
 
-      - name: Build Orm
-        if: ${{ success() }}
-        timeout-minutes: 5
-        run: dotnet build Orm.sln -c ${{ inputs.build_config }}
-
       - name: Setup .NETs
         if: ${{ success() }}
         timeout-minutes: 2
         uses: ./.github/actions/setup-dotnets
         with:
           target_framework: ${{ env.DO_TargetFrameworks }}
 
+      - name: Build Orm
+        if: ${{ success() }}
+        timeout-minutes: 5
+        run: dotnet build Orm.sln -c ${{ inputs.build_config }}
+
+      
+
       # Since composite action syntax does not allow to define step timeout
       # we have to run Reprocessing project here, because it may stuck in forever-loop
       - name: Test Reprocessing extension set of tests

.github/workflows/reusable-storage-independant-tests.yml

@@ -84,18 +84,18 @@ jobs:
         if: ${{ inputs.specific_sha != '' && github.reg_type == 'branch' }}
         run: git checkout ${{ inputs.specific_sha }}
 
-      - name: Build Orm
-        if: ${{ success() }}
-        timeout-minutes: 5
-        run: dotnet build Orm.sln -c ${{ inputs.build_config }}
-
       - name: Setup .NETs
         if: ${{ success() }}
         timeout-minutes: 2
         uses: ./.github/actions/setup-dotnets
         with:
           target_framework: ${{ env.DO_TargetFrameworks }}
 
+      - name: Build Orm
+        if: ${{ success() }}
+        timeout-minutes: 5
+        run: dotnet build Orm.sln -c ${{ inputs.build_config }}
+
       - name: Run tests
         id: complex_tests
         if: ${{ success() }}

Orm/Xtensive.Orm.Manual/Prefetch/PrefetchTest.cs

@@ -180,7 +180,7 @@ public async Task MainAsyncTest()
           .Prefetch(p => p.Photo) // Lazy load field
           .Prefetch(p => p.Employees.Prefetch(e => e.Photo)) // EntitySet Employees and lazy load field of each of its items with the limit on number of items to be loaded
           .Prefetch(p => p.Manager.Photo); // Referenced entity and lazy load field for each of them
-        await foreach (var person in people.AsAsyncEnumerable()) {
+        await foreach (var person in people) {
           var accessor = DirectStateAccessor.Get(person);
           Assert.That(accessor.GetFieldState("Photo"), Is.EqualTo(PersistentFieldState.Loaded));
           Assert.That(accessor.GetFieldState("Manager"), Is.EqualTo(PersistentFieldState.Loaded));
@@ -275,7 +275,7 @@ orderby person.Name
           .Prefetch(p => p.Employees // EntitySet Employees
             .Prefetch(e => e.Photo)) // and lazy load field of each of its items
           .Prefetch(p => p.Manager); // Referenced entity
-        await foreach (var person in prefetchedPeople.AsAsyncEnumerable()) {
+        await foreach (var person in prefetchedPeople) {
           var accessor = DirectStateAccessor.Get(person);
           Assert.That(accessor.GetFieldState("Photo"), Is.EqualTo(PersistentFieldState.Loaded));
           Assert.That(accessor.GetFieldState("Manager"), Is.EqualTo(PersistentFieldState.Loaded));
@@ -362,7 +362,7 @@ public async Task DelayedQueryAsyncTest()
           .Prefetch(p => p.Photo) // Lazy load field
           .Prefetch(p => p.Employees.Prefetch(e => e.Photo)) // EntitySet Employees and lazy load field of each of its items with the limit on number of items to be loaded
           .Prefetch(p => p.Manager.Photo); // Referenced entity and lazy load field for each of them
-        await foreach (var person in people.AsAsyncEnumerable()) {
+        await foreach (var person in people) {
           var accessor = DirectStateAccessor.Get(person);
           Assert.That(accessor.GetFieldState("Photo"), Is.EqualTo(PersistentFieldState.Loaded));
           Assert.That(accessor.GetFieldState("Manager"), Is.EqualTo(PersistentFieldState.Loaded));
@@ -450,7 +450,7 @@ public async Task CachedQueryAsyncTest()
           .Prefetch(p => p.Photo) // Lazy load field
           .Prefetch(p => p.Employees.Prefetch(e => e.Photo)) // EntitySet Employees and lazy load field of each of its items with the limit on number of items to be loaded
           .Prefetch(p => p.Manager.Photo); // Referenced entity and lazy load field for each of them
-        await foreach (var person in people.AsAsyncEnumerable()) {
+        await foreach (var person in people) {
           var accessor = DirectStateAccessor.Get(person);
           Assert.That(accessor.GetFieldState("Photo"), Is.EqualTo(PersistentFieldState.Loaded));
           Assert.That(accessor.GetFieldState("Manager"), Is.EqualTo(PersistentFieldState.Loaded));

Orm/Xtensive.Orm.Tests.FSharp/Model.fs

@@ -93,4 +93,4 @@ type X() =
   [<Field>]
   member this.TimeSpanField
     with get() = this.GetFieldValue<System.TimeSpan> (nameof this.TimeSpanField)
-    and set(v: System.TimeSpan) = this.SetFieldValue (nameof this.TimeSpanField, v)
+    and set(v: System.TimeSpan) = this.SetFieldValue (nameof this.TimeSpanField, v)

Orm/Xtensive.Orm.Tests.FSharp/QueryEntityBackTest.fs

@@ -32,4 +32,5 @@ type Fixture() =
     let list = query |> Seq.toArray
     Assert.That(list.Length, Is.EqualTo(1))
     let fetched = list.[0]
-    Assert.That(fetched.Name, Is.EqualTo("John"))
+    Assert.That(fetched.Name, Is.EqualTo("John"))
+

Orm/Xtensive.Orm.Tests.FSharp/Xtensive.Orm.Tests.FSharp.fsproj

@@ -28,8 +28,11 @@
     <ProjectReference Include="..\Xtensive.Orm\Xtensive.Orm.csproj" />
   </ItemGroup>
   <ItemGroup>
+    <!-- Keep it before any tests -->
     <Compile Include="FsUnit.fs" />
     <Compile Include="Model.fs" />
+  </ItemGroup>
+  <ItemGroup>
     <Compile Include="ArithmeticOperationsCompilersTest.fs" />
     <Compile Include="ComparisonCompilersTest.fs" />
     <Compile Include="DateTimeCompilersTest.fs" />

Orm/Xtensive.Orm.Tests/Storage/Prefetch/PrefetchTest.cs

@@ -181,8 +181,7 @@ public async Task PrefetchGraphPerformanceAsyncTest()
           .Prefetch(i => i.InvoiceLines
             .Prefetch(id => id.Track)
             .Prefetch(id => id.Track.Album)
-            .Prefetch(id => id.Track.Bytes))
-          .AsAsyncEnumerable();
+            .Prefetch(id => id.Track.Bytes));
         await foreach (var invoice in invoices) {
           var id = invoice.InvoiceId;
           var name = invoice.Customer.CompanyName;
@@ -247,7 +246,7 @@ public async Task EnumerableOfNonEntityAsyncTest()
       await using (var session = await Domain.OpenSessionAsync())
       await using (var tx = session.OpenTransaction()) {
         var invoices = session.Query.Many<Invoice>(keys)
-          .Prefetch(o => o.DesignatedEmployee).AsAsyncEnumerable();
+          .Prefetch(o => o.DesignatedEmployee);
         var invoiceType = Domain.Model.Types[typeof(Invoice)];
         var employeeField = invoiceType.Fields[nameof(Invoice.DesignatedEmployee)];
         var employeeType = Domain.Model.Types[typeof(Employee)];
@@ -361,7 +360,7 @@ public async Task PrefetchManyNotFullBatchAsyncTest()
         var invoicesField = Domain.Model.Types[typeof (Track)].Fields["Playlists"];
         var invoiceLinesField = Domain.Model.Types[typeof (Playlist)].Fields["Tracks"];
         var tracks = session.Query.All<Track>().Take(50)
-          .Prefetch(t => t.Playlists.Prefetch(il => il.Tracks)).AsAsyncEnumerable();
+          .Prefetch(t => t.Playlists.Prefetch(il => il.Tracks));
         int count1 = 0, count2 = 0;
         await foreach (var track in tracks) {
           count1++;
@@ -413,7 +412,7 @@ public async Task PrefetchManySeveralBatchesAsyncTest()
         var trackField = Domain.Model.Types[typeof(InvoiceLine)].Fields[nameof(InvoiceLine.Track)];
         var invoices = session.Query.All<Invoice>()
           .Take(90)
-          .Prefetch(o => o.InvoiceLines.Prefetch(od => od.Track)).AsAsyncEnumerable();
+          .Prefetch(o => o.InvoiceLines.Prefetch(od => od.Track));
         int count1 = 0, count2 = 0;
         await foreach (var invoice in invoices) {
           count1++;
@@ -483,7 +482,7 @@ public async Task PrefetchSingleAsyncTest()
         var employeeType = Domain.Model.Types[typeof(Employee)];
         var invoiceType = Domain.Model.Types[typeof(Invoice)];
         var invoices = session.Query.Many<Invoice>(keys)
-          .Prefetch(o => o.DesignatedEmployee.Invoices).AsAsyncEnumerable();
+          .Prefetch(o => o.DesignatedEmployee.Invoices);
         var count = 0;
         await foreach (var invoice in invoices) {
           Assert.That(invoice.Key, Is.EqualTo(keys[count]));
@@ -674,7 +673,7 @@ public async Task SimultaneouslyUsageOfMultipleEnumeratorsAsyncTest()
       await using (var session = await Domain.OpenSessionAsync())
       await using (var tx = session.OpenTransaction()) {
         var source = session.Query.All<Invoice>().ToList();
-        var prefetchQuery = source.Prefetch(i => i.InvoiceLines).AsAsyncEnumerable();
+        var prefetchQuery = source.Prefetch(i => i.InvoiceLines);
         await using (var enumerator0 = prefetchQuery.GetAsyncEnumerator()) {
           _ = await enumerator0.MoveNextAsync();
           _ = await enumerator0.MoveNextAsync();
@@ -729,7 +728,7 @@ public async Task RootElementIsNullPrefetchAsyncTest()
 
         await using (var tx = session.OpenTransaction()) {
           var books = session.Query.All<PrefetchModel.Book>().AsEnumerable()
-            .Concat(Enumerable.Repeat<PrefetchModel.Book>(null, 1)).Prefetch(b => b.Title).AsAsyncEnumerable();
+            .Concat(Enumerable.Repeat<PrefetchModel.Book>(null, 1)).Prefetch(b => b.Title);
           var titleField = Domain.Model.Types[typeof(PrefetchModel.Book)].Fields[nameof(PrefetchModel.Book.Title)];
           var titleType = Domain.Model.Types[typeof(PrefetchModel.Title)];
           var count = 0;
@@ -783,7 +782,7 @@ public async Task NestedPrefetchWhenChildElementIsNullAsyncTest()
 
         await using (var tx = session.OpenTransaction()) {
           var prefetcher = session.Query.All<PrefetchModel.Book>()
-            .Prefetch(b => b.Title.Book).AsAsyncEnumerable();
+            .Prefetch(b => b.Title.Book);
           var titleField = Domain.Model.Types[typeof(PrefetchModel.Book)].Fields[nameof(PrefetchModel.Book.Title)];
           var titleType = Domain.Model.Types[typeof(PrefetchModel.Title)];
           await foreach (var book in prefetcher) {
@@ -837,7 +836,7 @@ public async Task NestedPrefetchWhenRootElementIsNullAsyncTest()
 
         await using (var tx = session.OpenTransaction()) {
           var books = session.Query.All<PrefetchModel.Book>().AsEnumerable().Concat(Enumerable.Repeat<PrefetchModel.Book>(null, 1))
-            .Prefetch(b => b.Title.Book).AsAsyncEnumerable();
+            .Prefetch(b => b.Title.Book);
           var titleField = Domain.Model.Types[typeof(PrefetchModel.Book)].Fields[nameof(PrefetchModel.Book.Title)];
           var titleType = Domain.Model.Types[typeof(PrefetchModel.Title)];
           var count = 0;
@@ -883,7 +882,7 @@ public async Task StructureFieldsPrefetchAsyncTest()
       await using (var tx = session.OpenTransaction()) {
         var containers = session.Query.Many<PrefetchModel.OfferContainer>(Enumerable.Repeat(containerKey, 1))
           .Prefetch(oc => oc.RealOffer.Book)
-          .Prefetch(oc => oc.IntermediateOffer.RealOffer.BookShop).AsAsyncEnumerable();
+          .Prefetch(oc => oc.IntermediateOffer.RealOffer.BookShop);
         await foreach (var key in containers) {
           PrefetchTestHelper.AssertOnlyDefaultColumnsAreLoaded(book0Key, book0Key.TypeInfo, session);
           PrefetchTestHelper.AssertOnlyDefaultColumnsAreLoaded(bookShop1Key, bookShop1Key.TypeInfo, session);
@@ -917,7 +916,7 @@ public async Task StructurePrefetchAsyncTest()
       await using (var session = await Domain.OpenSessionAsync())
       await using (var tx = session.OpenTransaction()) {
         var containers = session.Query.Many<PrefetchModel.OfferContainer>(Enumerable.Repeat(containerKey, 1))
-          .Prefetch(oc => oc.IntermediateOffer).AsAsyncEnumerable();
+          .Prefetch(oc => oc.IntermediateOffer);
         await foreach (var key in containers) {
           PrefetchTestHelper.AssertOnlySpecifiedColumnsAreLoaded(containerKey, containerKey.TypeInfo, session,
             field => PrefetchTestHelper.IsFieldToBeLoadedByDefault(field) || field.Name.StartsWith("IntermediateOffer"));

Orm/Xtensive.Orm/Orm/PrefetchQuery.cs

@@ -19,8 +19,27 @@ namespace Xtensive.Orm
   /// initial query result.
   /// </summary>
   /// <typeparam name="TElement">The type of the queried elements.</typeparam>
-  public readonly struct PrefetchQuery<TElement> : IEnumerable<TElement>
+  public readonly struct PrefetchQuery<TElement> : IEnumerable<TElement>, IAsyncEnumerable<TElement>
   {
+    #region Nested types
+    private class ExecuteAsyncResult : IEnumerable<TElement>
+    {
+      private readonly List<TElement> items;
+      // We need to hold StrongReferenceContainer to prevent loaded entities from being collected
+      private readonly StrongReferenceContainer referenceContainer;
+
+      IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+      public IEnumerator<TElement> GetEnumerator() => items.GetEnumerator();
+
+      public ExecuteAsyncResult(List<TElement> items, StrongReferenceContainer referenceContainer)
+      {
+        this.items = items;
+        this.referenceContainer = referenceContainer;
+      }
+    }
+    #endregion
+
     private readonly Session session;
     private readonly IEnumerable<TElement> source;
     private readonly SinglyLinkedList<KeyExtractorNode<TElement>> nodes;
@@ -38,38 +57,25 @@ internal PrefetchQuery<TElement> RegisterPath<TValue>(Expression<Func<TElement,
     public IEnumerator<TElement> GetEnumerator() =>
       new PrefetchQueryEnumerable<TElement>(session, source, nodes).GetEnumerator();
 
+    /// <inheritdoc />
+    public IAsyncEnumerator<TElement> GetAsyncEnumerator(CancellationToken token = default) =>
+      new PrefetchQueryAsyncEnumerable<TElement>(session, source, nodes).GetAsyncEnumerator(token);
+
     /// <summary>
     /// Transforms <see cref="PrefetchQuery{TElement}"/> to an <see cref="IAsyncEnumerable{T}"/> sequence.
     /// </summary>
+    [Obsolete("PrefetchQuery itself is an IAsyncEnumerable implementation")]
     public IAsyncEnumerable<TElement> AsAsyncEnumerable() =>
       new PrefetchQueryAsyncEnumerable<TElement>(session, source, nodes);
 
-    private class ExecuteAsyncResult : IEnumerable<TElement>
-    {
-      private readonly List<TElement> items;
-      // We need to hold StrongReferenceContainer to prevent loaded entities from being collected
-      private readonly StrongReferenceContainer referenceContainer;
-
-      IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
-
-      public IEnumerator<TElement> GetEnumerator() => items.GetEnumerator();
-
-      public ExecuteAsyncResult(List<TElement> items, StrongReferenceContainer referenceContainer)
-      {
-        this.items = items;
-        this.referenceContainer = referenceContainer;
-      }
-    }
-
     /// <summary>
     /// Asynchronously executes given <see cref="PrefetchQuery{TElement}"/> instance.
     /// </summary>
     /// <remarks>
     /// <para>
     /// This method internally puts all elements of the resulting sequence to a list
     /// and then it wraps mentioned list as a <see cref="QueryResult{TItem}"/>.
-    /// As a consequence it is more efficient to use asynchronous enumeration over result of
-    /// <see cref="AsAsyncEnumerable"/> method call because it can perform lazily
+    /// As a consequence it is more efficient to use asynchronous enumeration because it can perform lazily
     /// not putting everything into intermediate list.
     /// </para>
     /// <para> Multiple active operations are not supported. Use <see langword="await"/>

Orm/Xtensive.Orm/Orm/Providers/DomainHandler.cs

@@ -143,11 +143,9 @@ protected virtual IEnumerable<Type> GetProviderCompilerContainers()
 
       };
       var result = basicCompilerContainers;
-      var defaultLoadedAssemblies = AssemblyLoadContext.Default.Assemblies;
-      var currentLoadedAssemblies = AssemblyLoadContext.CurrentContextualReflectionContext.Assemblies;
+      var allLoadedAssemblies = AssemblyLoadContext.All.SelectMany(static c => c.Assemblies);
       // dynamic registration to not cause assembly loading
-      if (defaultLoadedAssemblies.Any(static a => a.GetName().Name.Equals("FSharp.Core", StringComparison.OrdinalIgnoreCase))
-        || defaultLoadedAssemblies.Any(static a => a.GetName().Name.Equals("FSharp.Core", StringComparison.OrdinalIgnoreCase))) {
+      if (allLoadedAssemblies.Any(static a => a.GetName().Name.Equals("FSharp.Core", StringComparison.OrdinalIgnoreCase))) {
         result = result.Concat(new[] {
           typeof (FSharpMathOperationsCompilers),
           typeof (FSharpOperatorsCompilers),
@@ -156,8 +154,7 @@ protected virtual IEnumerable<Type> GetProviderCompilerContainers()
         });
       }
 
-      if (defaultLoadedAssemblies.Any(static a => a.GetName().Name.Equals("Microsoft.VisualBasic", StringComparison.OrdinalIgnoreCase))
-        || defaultLoadedAssemblies.Any(static a => a.GetName().Name.Equals("Microsoft.VisualBasic", StringComparison.OrdinalIgnoreCase))) {
+      if (allLoadedAssemblies.Any(static a => a.GetName().Name.StartsWith("Microsoft.VisualBasic", StringComparison.OrdinalIgnoreCase))) {
         result = result.Concat(new[] {
           typeof (VbConversionsCompilers),
           typeof (VbStringsCompilers),

global.json

@@ -0,0 +1,6 @@
+{
+  "sdk": {
+    "version": "10.0.100",
+    "rollForward": "latestMinor"
+  }
+}