Make EntityEntryGraphIterator publicly usable

src/EFCore/ChangeTracking/EntityEntryGraphNode.cs

@@ -89,26 +89,15 @@ InternalEntityEntry IInfrastructure<InternalEntityEntry>.Instance
         => _entry;
 
     /// <summary>
-    ///     Creates a new node for the entity that is being traversed next in the graph.
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    /// <param name="currentNode">The node that the entity is being traversed from.</param>
-    /// <param name="internalEntityEntry">
-    ///     The internal entry tracking information about the entity being traversed to.
-    /// </param>
-    /// <param name="reachedVia">The navigation property that is being traversed to reach the new node.</param>
-    /// <returns>The newly created node.</returns>
+    [EntityFrameworkInternal]
     public virtual EntityEntryGraphNode CreateNode(
         EntityEntryGraphNode currentNode,
         InternalEntityEntry internalEntityEntry,
         INavigationBase reachedVia)
-    {
-        Check.NotNull(currentNode, nameof(currentNode));
-        Check.NotNull(internalEntityEntry, nameof(internalEntityEntry));
-        Check.NotNull(reachedVia, nameof(reachedVia));
-
-        return new EntityEntryGraphNode(
-            internalEntityEntry,
-            currentNode.Entry.GetInfrastructure(),
-            reachedVia);
-    }
+        => new(internalEntityEntry, currentNode.Entry.GetInfrastructure(), reachedVia);
 }

src/EFCore/ChangeTracking/EntityEntryGraphNode`.cs

@@ -32,33 +32,41 @@ public EntityEntryGraphNode(
         NodeState = state;
     }
 
+    /// <summary>
+    ///     Creates a new node in the entity graph.
+    /// </summary>
+    /// <param name="entry">The entry for the entity represented by this node.</param>
+    /// <param name="state">A state object that will be available when processing each node.</param>
+    /// <param name="sourceEntry">The entry from which this node was reached, or <see langword="null" /> if this is the root node.</param>
+    /// <param name="inboundNavigation">The navigation from the source node to this node, or <see langword="null" /> if this is the root node.</param>
+    public EntityEntryGraphNode(
+        EntityEntry entry,
+        TState state,
+        EntityEntry? sourceEntry,
+        INavigationBase? inboundNavigation)
+        : this(entry.GetInfrastructure(), state, sourceEntry?.GetInfrastructure(), inboundNavigation)
+    {
+    }
+
     /// <summary>
     ///     Gets or sets state that will be available to all nodes that are visited after this node.
     /// </summary>
     public virtual TState NodeState { get; set; }
 
     /// <summary>
-    ///     Creates a new node for the entity that is being traversed next in the graph.
+    ///     This is an internal API that supports the Entity Framework Core infrastructure and not subject to
+    ///     the same compatibility standards as public APIs. It may be changed or removed without notice in
+    ///     any release. You should only use it directly in your code with extreme caution and knowing that
+    ///     doing so can result in application failures when updating to a new Entity Framework Core release.
     /// </summary>
-    /// <param name="currentNode">The node that the entity is being traversed from.</param>
-    /// <param name="internalEntityEntry">
-    ///     The internal entry tracking information about the entity being traversed to.
-    /// </param>
-    /// <param name="reachedVia">The navigation property that is being traversed to reach the new node.</param>
-    /// <returns>The newly created node.</returns>
+    [EntityFrameworkInternal]
     public override EntityEntryGraphNode CreateNode(
         EntityEntryGraphNode currentNode,
         InternalEntityEntry internalEntityEntry,
         INavigationBase reachedVia)
-    {
-        Check.NotNull(currentNode, nameof(currentNode));
-        Check.NotNull(internalEntityEntry, nameof(internalEntityEntry));
-        Check.NotNull(reachedVia, nameof(reachedVia));
-
-        return new EntityEntryGraphNode<TState>(
+        => new EntityEntryGraphNode<TState>(
             internalEntityEntry,
             ((EntityEntryGraphNode<TState>)currentNode).NodeState,
             currentNode.Entry.GetInfrastructure(),
             reachedVia);
-    }
 }

test/EFCore.Tests/ChangeTracking/TrackGraphTestBase.cs

@@ -23,6 +23,88 @@ protected override IList<string> TrackGraph(DbContext context, object root, Acti
 
             return traversal;
         }
+
+        [ConditionalTheory] // Issue #26461
+        [InlineData(false)]
+        [InlineData(true)]
+        public async Task Can_iterate_over_graph_using_public_surface(bool async)
+        {
+            using var context = new EarlyLearningCenter(GetType().Name);
+            var category = new Category
+            {
+                Id = 1,
+                Products = new List<Product>
+                {
+                    new()
+                    {
+                        Id = 1,
+                        CategoryId = 1,
+                        Details = new ProductDetails { Id = 1 }
+                    },
+                    new()
+                    {
+                        Id = 2,
+                        CategoryId = 1,
+                        Details = new ProductDetails { Id = 2 }
+                    },
+                    new()
+                    {
+                        Id = 3,
+                        CategoryId = 1,
+                        Details = new ProductDetails { Id = 3 }
+                    }
+                }
+            };
+
+            var rootEntry = context.Attach(category);
+
+            var graphIterator = context.GetService<IEntityEntryGraphIterator>();
+
+            var visited = new HashSet<object>();
+            var traversal = new List<string>();
+
+            bool Callback(EntityEntryGraphNode<HashSet<object>> node)
+            {
+                if (node.NodeState.Contains(node.Entry.Entity))
+                {
+                    return false;
+                }
+
+                node.NodeState.Add(node.Entry.Entity);
+
+                traversal.Add(NodeString(node));
+
+                return true;
+            }
+
+            if (async)
+            {
+                await graphIterator.TraverseGraphAsync(
+                    new EntityEntryGraphNode<HashSet<object>>(rootEntry, visited, null, null),
+                    (node, _) => Task.FromResult(Callback(node)));
+            }
+            else
+            {
+                graphIterator.TraverseGraph(
+                    new EntityEntryGraphNode<HashSet<object>>(rootEntry, visited, null, null),
+                    Callback);
+            }
+
+            Assert.Equal(
+                new List<string>
+                {
+                    "<None> -----> Category:1",
+                    "Category:1 ---Products--> Product:1",
+                    "Product:1 ---Details--> ProductDetails:1",
+                    "Category:1 ---Products--> Product:2",
+                    "Product:2 ---Details--> ProductDetails:2",
+                    "Category:1 ---Products--> Product:3",
+                    "Product:3 ---Details--> ProductDetails:3"
+                },
+                traversal);
+
+            Assert.Equal(7, visited.Count);
+        }
     }
 
     public class TrackGraphTestWithState : TrackGraphTestBase
@@ -1152,16 +1234,6 @@ public void TrackGraph_overload_can_visit_an_already_attached_graph()
         Assert.Equal(7, visited.Count);
     }
 
-    private static void AssertValuesSaved(int id, int someInt, string someString)
-    {
-        using var context = new TheShadows();
-        var entry = context.Entry(context.Set<Dark>().Single(e => EF.Property<int>(e, "Id") == id));
-
-        Assert.Equal(id, entry.Property<int>("Id").CurrentValue);
-        Assert.Equal(someInt, entry.Property<int>("SomeInt").CurrentValue);
-        Assert.Equal(someString, entry.Property<string>("SomeString").CurrentValue);
-    }
-
     private class TheShadows : DbContext
     {
         protected internal override void OnModelCreating(ModelBuilder modelBuilder)