Add optimized property accessors for entity metadata

Author: fabien.menager

src/PhenX.EntityFrameworkCore.BulkInsert/Graph/GraphBulkInsertOrchestrator.cs

@@ -1,5 +1,3 @@
-using System.Collections.Concurrent;
-using System.Linq.Expressions;
 using System.Reflection;
 
 using Microsoft.EntityFrameworkCore;
@@ -17,8 +15,6 @@ namespace PhenX.EntityFrameworkCore.BulkInsert.Graph;
 /// </summary>
 internal sealed class GraphBulkInsertOrchestrator
 {
-    private static readonly ConcurrentDictionary<(Type, string), Action<object, object?>> PropertySetters = new();
-    private static readonly ConcurrentDictionary<(Type, string), Func<object, object?>> PropertyGetters = new();
 
     private readonly DbContext _context;
     private readonly MetadataProvider _metadataProvider;
@@ -76,15 +72,15 @@ public async Task<GraphInsertResult<T>> InsertGraph<T>(
             PropagateParentForeignKeys(entitiesToInsert, entityType, graphMetadata);
 
             // Insert entities of this type
-            await InsertEntitiesOfType(sync, _context, entityType, entitiesToInsert, options, provider, ctk);
+            await InsertEntitiesOfType(sync, _context, entityType, entitiesToInsert, options, provider, graphMetadata, ctk);
 
             totalInserted += entitiesToInsert.Count;
         }
 
         // 3. Insert join table records for many-to-many relationships
         if (collectionResult.JoinRecords.Count > 0)
         {
-            await InsertJoinRecords(sync, _context, collectionResult.JoinRecords, options, provider, ctk);
+            await InsertJoinRecords(sync, _context, collectionResult.JoinRecords, options, provider, graphMetadata, ctk);
         }
 
         // Return root entities
@@ -110,6 +106,12 @@ private static void PropagateParentForeignKeys(
             return;
         }
 
+        var entityMetadata = graphMetadata.GetEntityMetadata(entityType);
+        if (entityMetadata == null)
+        {
+            return;
+        }
+
         // For each FK relationship, propagate PK values from parent entities
         foreach (var fk in efEntityType.GetForeignKeys())
         {
@@ -125,12 +127,18 @@ private static void PropagateParentForeignKeys(
             foreach (var entity in entities)
             {
                 // Get the parent entity via navigation property
-                var parentEntity = GetPropertyValue(entity, navigationPropertyName);
+                var parentEntity = entityMetadata.GetPropertyValue(entity, navigationPropertyName);
                 if (parentEntity == null)
                 {
                     continue;
                 }
 
+                var parentMetadata = graphMetadata.GetEntityMetadata(parentEntity.GetType());
+                if (parentMetadata == null)
+                {
+                    continue;
+                }
+
                 // Copy PK values from parent to FK properties on this entity
                 var fkProperties = fk.Properties;
                 var pkProperties = fk.PrincipalKey.Properties;
@@ -147,8 +155,8 @@ private static void PropagateParentForeignKeys(
                         continue;
                     }
 
-                    var pkValue = GetPropertyValue(parentEntity, pkProp.Name);
-                    SetPropertyValue(entity, fkProp.Name, pkValue);
+                    var pkValue = parentMetadata.GetPropertyValue(parentEntity, pkProp.Name);
+                    entityMetadata.SetPropertyValue(entity, fkProp.Name, pkValue);
                 }
             }
         }
@@ -161,14 +169,15 @@ private async Task InsertEntitiesOfType(
         List<object> entities,
         BulkInsertOptions options,
         IBulkInsertProvider provider,
+        GraphMetadata graphMetadata,
         CancellationToken ctk)
     {
         // Use reflection to call the generic BulkInsert method
         var method = typeof(GraphBulkInsertOrchestrator)
             .GetMethod(nameof(InsertEntitiesGenericAsync), BindingFlags.NonPublic | BindingFlags.Instance)!
             .MakeGenericMethod(entityType);
 
-        var task = (Task)method.Invoke(this, [context, entities, options, provider, ctk])!;
+        var task = (Task)method.Invoke(this, [context, entities, options, provider, graphMetadata, ctk])!;
         await task;
     }
 
@@ -177,6 +186,7 @@ private async Task InsertEntitiesGenericAsync<TEntity>(
         List<object> entities,
         BulkInsertOptions options,
         IBulkInsertProvider provider,
+        GraphMetadata graphMetadata,
         CancellationToken ctk) where TEntity : class
     {
         var typedEntities = entities.Cast<TEntity>().ToList();
@@ -202,7 +212,11 @@ private async Task InsertEntitiesGenericAsync<TEntity>(
             }
 
             // Copy generated IDs back to original entities
-            CopyGeneratedIds(typedEntities, insertedEntities, tableInfo);
+            var entityMetadata = graphMetadata.GetEntityMetadata(typeof(TEntity));
+            if (entityMetadata != null)
+            {
+                CopyGeneratedIds(typedEntities, insertedEntities, tableInfo, entityMetadata);
+            }
         }
         else
         {
@@ -214,7 +228,8 @@ private async Task InsertEntitiesGenericAsync<TEntity>(
     private void CopyGeneratedIds<TEntity>(
         List<TEntity> originalEntities,
         List<TEntity> insertedEntities,
-        TableMetadata tableInfo) where TEntity : class
+        TableMetadata tableInfo,
+        EntityMetadata entityMetadata) where TEntity : class
     {
         if (originalEntities.Count != insertedEntities.Count)
         {
@@ -241,8 +256,8 @@ private void CopyGeneratedIds<TEntity>(
 
             foreach (var pkProp in pkProps)
             {
-                var value = GetPropertyValue(inserted, pkProp.PropertyName);
-                SetPropertyValue(original, pkProp.PropertyName, value);
+                var value = entityMetadata.GetPropertyValue(inserted, pkProp.PropertyName);
+                entityMetadata.SetPropertyValue(original, pkProp.PropertyName, value);
             }
         }
     }
@@ -253,6 +268,7 @@ private async Task InsertJoinRecords(
         List<JoinRecord> joinRecords,
         BulkInsertOptions options,
         IBulkInsertProvider provider,
+        GraphMetadata graphMetadata,
         CancellationToken ctk)
     {
         // Group join records by join entity type
@@ -278,11 +294,23 @@ private async Task InsertJoinRecords(
                 continue;
             }
 
+            // Get entity metadata for join type
+            var joinEntityMetadata = graphMetadata.GetEntityMetadata(joinEntityType);
+
             // Create join table entries
             var joinEntities = new List<object>();
 
             foreach (var record in records)
             {
+                // Get metadata for left and right entities
+                var leftMetadata = graphMetadata.GetEntityMetadata(record.LeftEntity.GetType());
+                var rightMetadata = graphMetadata.GetEntityMetadata(record.RightEntity.GetType());
+
+                if (leftMetadata == null || rightMetadata == null)
+                {
+                    continue;
+                }
+
                 // Create a dictionary-based join entity
                 var joinEntry = Activator.CreateInstance(joinEntityType);
                 if (joinEntry == null)
@@ -304,14 +332,14 @@ private async Task InsertJoinRecords(
                     var fkProp = fk.Properties[i];
                     var pkProp = fk.PrincipalKey.Properties[i];
 
-                    var pkValue = GetPropertyValue(record.LeftEntity, pkProp.Name);
+                    var pkValue = leftMetadata.GetPropertyValue(record.LeftEntity, pkProp.Name);
                     if (dictEntry != null)
                     {
                         dictEntry[fkProp.Name] = pkValue!;
                     }
-                    else
+                    else if (joinEntityMetadata != null)
                     {
-                        SetPropertyValue(joinEntry, fkProp.Name, pkValue);
+                        joinEntityMetadata.SetPropertyValue(joinEntry, fkProp.Name, pkValue);
                     }
                 }
 
@@ -321,14 +349,14 @@ private async Task InsertJoinRecords(
                     var fkProp = inverseFk.Properties[i];
                     var pkProp = inverseFk.PrincipalKey.Properties[i];
 
-                    var pkValue = GetPropertyValue(record.RightEntity, pkProp.Name);
+                    var pkValue = rightMetadata.GetPropertyValue(record.RightEntity, pkProp.Name);
                     if (dictEntry != null)
                     {
                         dictEntry[fkProp.Name] = pkValue!;
                     }
-                    else
+                    else if (joinEntityMetadata != null)
                     {
-                        SetPropertyValue(joinEntry, fkProp.Name, pkValue);
+                        joinEntityMetadata.SetPropertyValue(joinEntry, fkProp.Name, pkValue);
                     }
                 }
 
@@ -374,50 +402,4 @@ private async Task InsertJoinEntities(
         }
         await task;
     }
-
-    private static object? GetPropertyValue(object entity, string propertyName)
-    {
-        var key = (entity.GetType(), propertyName);
-        var getter = PropertyGetters.GetOrAdd(key, k =>
-        {
-            var property = k.Item1.GetProperty(k.Item2, BindingFlags.Public | BindingFlags.Instance);
-            if (property == null)
-            {
-                return _ => null;
-            }
-
-            var param = Expression.Parameter(typeof(object), "obj");
-            var cast = Expression.Convert(param, k.Item1);
-            var access = Expression.Property(cast, property);
-            var convertResult = Expression.Convert(access, typeof(object));
-
-            return Expression.Lambda<Func<object, object?>>(convertResult, param).Compile();
-        });
-
-        return getter(entity);
-    }
-
-    private static void SetPropertyValue(object entity, string propertyName, object? value)
-    {
-        var key = (entity.GetType(), propertyName);
-        var setter = PropertySetters.GetOrAdd(key, k =>
-        {
-            var property = k.Item1.GetProperty(k.Item2, BindingFlags.Public | BindingFlags.Instance);
-            if (property == null || !property.CanWrite)
-            {
-                return (_, _) => { };
-            }
-
-            var param = Expression.Parameter(typeof(object), "obj");
-            var valueParam = Expression.Parameter(typeof(object), "value");
-            var cast = Expression.Convert(param, k.Item1);
-            var access = Expression.Property(cast, property);
-            var convertValue = Expression.Convert(valueParam, property.PropertyType);
-            var assign = Expression.Assign(access, convertValue);
-
-            return Expression.Lambda<Action<object, object?>>(assign, param, valueParam).Compile();
-        });
-
-        setter(entity, value);
-    }
 }

src/PhenX.EntityFrameworkCore.BulkInsert/Metadata/EntityMetadata.cs

@@ -0,0 +1,87 @@
+using System.Collections.Concurrent;
+
+using Microsoft.EntityFrameworkCore.Metadata;
+
+namespace PhenX.EntityFrameworkCore.BulkInsert.Metadata;
+
+/// <summary>
+/// Metadata for an entity type with optimized property accessors.
+/// Getters and setters are computed on demand and cached.
+/// </summary>
+internal sealed class EntityMetadata
+{
+    private readonly ConcurrentDictionary<string, Func<object, object?>> _getters = new();
+    private readonly ConcurrentDictionary<string, Action<object, object?>> _setters = new();
+    private readonly IEntityType _entityType;
+
+    public EntityMetadata(IEntityType entityType)
+    {
+        _entityType = entityType;
+        ClrType = entityType.ClrType;
+    }
+
+    public Type ClrType { get; }
+
+    /// <summary>
+    /// Gets the value of a property from an entity using an optimized getter.
+    /// The getter is created on first access and cached for subsequent calls.
+    /// Returns null if the property is not found or is a shadow property.
+    /// </summary>
+    public object? GetPropertyValue(object entity, string propertyName)
+    {
+        var getter = _getters.GetOrAdd(propertyName, static (name, entityType) =>
+        {
+            var property = entityType.FindProperty(name);
+            if (property == null || property.IsShadowProperty())
+            {
+                // Try to find a navigation property
+                var navigation = entityType.FindNavigation(name);
+                if (navigation?.PropertyInfo != null)
+                {
+                    return PropertyAccessor.CreateGetter(navigation.PropertyInfo);
+                }
+
+                return _ => null;
+            }
+
+            var propertyInfo = property.PropertyInfo;
+            if (propertyInfo == null)
+            {
+                return _ => null;
+            }
+
+            return PropertyAccessor.CreateGetter(propertyInfo);
+        }, _entityType);
+
+        return getter(entity);
+    }
+
+    /// <summary>
+    /// Sets the value of a property on an entity using an optimized setter.
+    /// The setter is created on first access and cached for subsequent calls.
+    /// Does nothing if the property is not found, is a shadow property, or is not writable.
+    /// </summary>
+    public void SetPropertyValue(object entity, string propertyName, object? value)
+    {
+        var setter = _setters.GetOrAdd(propertyName, static (name, entityType) =>
+        {
+            var property = entityType.FindProperty(name);
+            if (property == null || property.IsShadowProperty())
+            {
+                return (_, _) => { };
+            }
+
+            var propertyInfo = property.PropertyInfo;
+            if (propertyInfo == null || !propertyInfo.CanWrite)
+            {
+                return (_, _) => { };
+            }
+
+            return PropertyAccessor.CreateSetter(propertyInfo);
+        }, _entityType);
+
+        setter(entity, value);
+    }
+}
+
+

src/PhenX.EntityFrameworkCore.BulkInsert/Metadata/GraphMetadata.cs

@@ -12,6 +12,7 @@ internal sealed class GraphMetadata
 {
     private readonly Dictionary<Type, IEntityType> _entityTypes;
     private readonly Dictionary<Type, List<NavigationMetadata>> _navigationsByType;
+    private readonly Dictionary<Type, EntityMetadata> _entityMetadataByType = [];
     private readonly BulkInsertOptions _options;
 
     public GraphMetadata(DbContext context, BulkInsertOptions options)
@@ -59,6 +60,27 @@ public IReadOnlyList<NavigationMetadata> GetNavigations(Type clrType)
             : [];
     }
 
+    /// <summary>
+    /// Gets or creates the entity metadata with optimized property accessors for a CLR type.
+    /// </summary>
+    public EntityMetadata? GetEntityMetadata(Type clrType)
+    {
+        if (_entityMetadataByType.TryGetValue(clrType, out var metadata))
+        {
+            return metadata;
+        }
+
+        var entityType = GetEntityType(clrType);
+        if (entityType == null)
+        {
+            return null;
+        }
+
+        metadata = new EntityMetadata(entityType);
+        _entityMetadataByType[clrType] = metadata;
+        return metadata;
+    }
+
     /// <summary>
     /// Determines the topological insertion order for a set of types based on FK dependencies.
     /// Parents are inserted before children to satisfy FK constraints.