EF Core: added support for primitive collections

Author: PawelGerr

Directory.Build.props

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <Copyright>(c) $([System.DateTime]::Now.Year), Pawel Gerr. All rights reserved.</Copyright>
-    <VersionPrefix>8.9.2</VersionPrefix>
+    <VersionPrefix>8.10.0</VersionPrefix>
     <Authors>Pawel Gerr</Authors>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PackageProjectUrl>https://github.com/PawelGerr/Thinktecture.Runtime.Extensions</PackageProjectUrl>

src/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Sources/EntityFrameworkCore/Conventions/ThinktectureConventionSetPlugin.cs

@@ -22,6 +22,10 @@ public ConventionSet ModifyConventions(ConventionSet conventionSet)
          conventionSet.NavigationAddedConventions.Add(convention);
          conventionSet.PropertyAddedConventions.Add(convention);
          conventionSet.EntityTypeAddedConventions.Add(convention);
+
+#if PRIMITIVE_COLLECTIONS
+         conventionSet.PropertyElementTypeChangedConventions.Add(convention);
+#endif
       }
 
       return conventionSet;

src/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Sources/EntityFrameworkCore/Conventions/ThinktectureConventionsPlugin.cs

@@ -8,7 +8,13 @@
 
 namespace Thinktecture.EntityFrameworkCore.Conventions;
 
-internal sealed class ThinktectureConventionsPlugin : INavigationAddedConvention, IPropertyAddedConvention, IEntityTypeAddedConvention
+internal sealed class ThinktectureConventionsPlugin
+   : INavigationAddedConvention,
+     IPropertyAddedConvention,
+     IEntityTypeAddedConvention
+#if PRIMITIVE_COLLECTIONS
+     , IPropertyElementTypeChangedConvention
+#endif
 {
    private readonly bool _validateOnWrite;
    private readonly bool _useConstructorForRead;
@@ -103,6 +109,31 @@ public void ProcessPropertyAdded(IConventionPropertyBuilder propertyBuilder, ICo
       ProcessProperty(propertyBuilder.Metadata);
    }
 
+#if PRIMITIVE_COLLECTIONS
+   public void ProcessPropertyElementTypeChanged(
+      IConventionPropertyBuilder propertyBuilder,
+      IElementType? newElementType,
+      IElementType? oldElementType,
+      IConventionContext<IElementType> context)
+   {
+      var elementType = propertyBuilder.Metadata.GetElementType();
+
+      if (elementType is null)
+         return;
+
+      var valueConverter = elementType.GetValueConverter();
+
+      if (valueConverter is not null)
+         return;
+
+      if (MetadataLookup.Find(elementType.ClrType) is not Metadata.Keyed metadata)
+         return;
+
+      elementType.SetValueConverter(GetValueConverter(metadata));
+      _configureEnumsAndKeyedValueObjects(propertyBuilder.Metadata);
+   }
+#endif
+
    private void ProcessNavigation(IConventionNavigation navigation)
    {
       var naviType = navigation.ClrType;

src/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Sources/Extensions/EntityTypeBuilderExtensions.cs

@@ -378,7 +378,7 @@ private static void AddConverterToNonNavigation(
       if (entity.IsIgnored(propertyInfo.Name))
          return;
 
-      // wil be handled by AddConverterForScalarProperties
+      // will be handled by AddConverterForScalarProperties
       if (entity.FindProperty(propertyInfo) is not null)
          return;
 
@@ -508,13 +508,43 @@ private static void AddConverterForScalarProperties(
          if (valueConverter is not null)
             continue;
 
+#if PRIMITIVE_COLLECTIONS
+         if (property.IsPrimitiveCollection)
+         {
+            AddConverterForPrimitiveCollections(property, validateOnWrite, useConstructorForRead, converterLookup, configure);
+            return;
+         }
+#endif
+
          if (MetadataLookup.Find(property.ClrType) is not Metadata.Keyed metadata)
             continue;
 
          SetConverterAndExecuteCallback(validateOnWrite, useConstructorForRead, converterLookup, configure, property, metadata);
       }
    }
 
+#if PRIMITIVE_COLLECTIONS
+   private static void AddConverterForPrimitiveCollections(
+      IMutableProperty property,
+      bool validateOnWrite,
+      bool useConstructorForRead,
+      Dictionary<Type, ValueConverter>? converterLookup,
+      Action<IMutableProperty> configure)
+   {
+      var elementType = property.GetElementType();
+
+      if (elementType is null)
+         return;
+
+      if (MetadataLookup.Find(elementType.ClrType) is not Metadata.Keyed metadata)
+         return;
+
+      var valueConverter = GetValueConverter(validateOnWrite, useConstructorForRead, converterLookup, metadata);
+      elementType.SetValueConverter(valueConverter);
+      configure(property);
+   }
+#endif
+
 #if COMPLEX_TYPES
    private static void AddConverterForComplexProperties(
       IMutableTypeBase entity,

src/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Sources/Extensions/PrimitiveCollectionBuilderExtensions.cs

@@ -0,0 +1,32 @@
+#if PRIMITIVE_COLLECTIONS
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Thinktecture.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Thinktecture;
+
+/// <summary>
+/// Provides extension methods for the <see cref="PrimitiveCollectionBuilder{TProperty}"/> class to configure value object conversions.
+/// </summary>
+public static class PrimitiveCollectionBuilderExtensions
+{
+   /// <summary>
+   /// Configures a primitive collection to use value object conversion.
+   /// </summary>
+   /// <typeparam name="TProperty">The element type of the collection.</typeparam>
+   /// <param name="primitiveCollectionBuilder">The primitive collection builder.</param>
+   /// <param name="validateOnWrite">Whether to validate the value when writing to the database.</param>
+   /// <param name="useConstructorForRead">For keyed value objects only. Whether to use the constructor when reading from the database.</param>
+   /// <returns>The primitive collection builder for chaining.</returns>
+   public static PrimitiveCollectionBuilder<TProperty> HasThinktectureValueConverter<TProperty>(
+      this PrimitiveCollectionBuilder<TProperty> primitiveCollectionBuilder,
+      bool validateOnWrite,
+      bool useConstructorForRead = true)
+   {
+      var elementType = primitiveCollectionBuilder.ElementType();
+      var converter = ThinktectureValueConverterFactory.Create(elementType.Metadata.ClrType, validateOnWrite, useConstructorForRead);
+      elementType.HasConversion(converter);
+
+      return primitiveCollectionBuilder;
+   }
+}
+#endif

src/Thinktecture.Runtime.Extensions.EntityFrameworkCore8/Thinktecture.Runtime.Extensions.EntityFrameworkCore8.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Description>Extends Entity Framework Core to support some components from Thinktecture.Runtime.Extensions.</Description>
     <PackageTags>smart-enum;value-object;discriminated-union;EntityFrameworkCore</PackageTags>
-    <DefineConstants>$(DefineConstants);COMPLEX_TYPES;USE_FIND_COMPLEX_PROPERTY_FIX;</DefineConstants>
+    <DefineConstants>$(DefineConstants);COMPLEX_TYPES;PRIMITIVE_COLLECTIONS;USE_FIND_COMPLEX_PROPERTY_FIX;</DefineConstants>
     <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
 

src/Thinktecture.Runtime.Extensions.EntityFrameworkCore9/Thinktecture.Runtime.Extensions.EntityFrameworkCore9.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Description>Extends Entity Framework Core to support some components from Thinktecture.Runtime.Extensions.</Description>
     <PackageTags>smart-enum;value-object;discriminated-union;EntityFrameworkCore</PackageTags>
-    <DefineConstants>$(DefineConstants);COMPLEX_TYPES;USE_FIND_COMPLEX_PROPERTY_FIX;</DefineConstants>
+    <DefineConstants>$(DefineConstants);COMPLEX_TYPES;PRIMITIVE_COLLECTIONS;USE_FIND_COMPLEX_PROPERTY_FIX;</DefineConstants>
     <TargetFramework>net8.0</TargetFramework>
   </PropertyGroup>
 

test/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Tests.Sources/EntityFrameworkCore/ValueConversion/ValueObjectValueConverterFactoryTests.cs

@@ -42,7 +42,14 @@ public async Task Should_write_and_read_enums_and_value_types()
                       Boundary = Boundary.Create(10, 20),
                       BoundaryWithCustomError = BoundaryWithCustomError.Create(11, 21),
                       BoundaryWithCustomFactoryNames = BoundaryWithCustomFactoryNames.Get(11, 21),
-                      IntBasedReferenceValueObjectWitCustomFactoryName = IntBasedReferenceValueObjectWithCustomFactoryNames.Get(1)
+                      IntBasedReferenceValueObjectWitCustomFactoryName = IntBasedReferenceValueObjectWithCustomFactoryNames.Get(1),
+#if PRIMITIVE_COLLECTIONS
+                      CollectionOfIntBasedReferenceValueObject =
+                      [
+                         IntBasedReferenceValueObject.Create(1),
+                         IntBasedReferenceValueObject.Create(2)
+                      ]
+#endif
                    };
       _ctx.Add(entity);
       await _ctx.SaveChangesAsync();

test/Thinktecture.Runtime.Extensions.EntityFrameworkCore.Tests.Sources/TestEntities/TestEntity_with_Enum_and_ValueObjects.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using Microsoft.EntityFrameworkCore;
 using Thinktecture.Runtime.Tests.TestEnums;
 using Thinktecture.Runtime.Tests.TestValueObjects;
@@ -27,6 +28,10 @@ public class TestEntity_with_Enum_and_ValueObjects
    public required StringBasedStructValueObject StringBasedStructValueObject { get; set; }
    public StringBasedReferenceValueObjectWithCustomError? StringBasedReferenceValueObjectWithCustomError { get; set; }
 
+#if PRIMITIVE_COLLECTIONS
+   public List<IntBasedReferenceValueObject> CollectionOfIntBasedReferenceValueObject { get; set; } = [];
+#endif
+
    public Boundary? Boundary { get; set; }
    public BoundaryWithCustomError? BoundaryWithCustomError { get; set; }
    public BoundaryWithCustomFactoryNames? BoundaryWithCustomFactoryNames { get; set; }
@@ -42,6 +47,10 @@ is ValueConverterRegistration.EntityConfiguration
 
       modelBuilder.Entity<TestEntity_with_Enum_and_ValueObjects>(builder =>
       {
+#if PRIMITIVE_COLLECTIONS
+         var primitiveCollectionBuilder = builder.PrimitiveCollection(e => e.CollectionOfIntBasedReferenceValueObject);
+#endif
+
          if (valueConverterRegistration == ValueConverterRegistration.PropertyConfiguration)
          {
             builder.Property(e => e.TestEnum).HasThinktectureValueConverter(true);
@@ -60,6 +69,10 @@ is ValueConverterRegistration.EntityConfiguration
             builder.Property(e => e.StringBasedReferenceValueObjectWithCustomError).HasThinktectureValueConverter(true);
 
             builder.Property(e => e.IntBasedReferenceValueObjectWitCustomFactoryName).HasThinktectureValueConverter(true);
+
+#if PRIMITIVE_COLLECTIONS
+            primitiveCollectionBuilder.HasThinktectureValueConverter(true);
+#endif
          }
 
          builder.OwnsOne(e => e.Boundary, navigationBuilder =>

test/Thinktecture.Runtime.Extensions.EntityFrameworkCore8.Tests/Thinktecture.Runtime.Extensions.EntityFrameworkCore8.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <DefineConstants>$(DefineConstants);COMPLEX_TYPES</DefineConstants>
+    <DefineConstants>$(DefineConstants);COMPLEX_TYPES;PRIMITIVE_COLLECTIONS;</DefineConstants>
     <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
   </PropertyGroup>