.Net 10

Author: phongnguyend

src/EntityFrameworkCore.SqlServer.SimpleBulks.Tests/Database/TestDbContext.cs

@@ -65,11 +65,10 @@ protected override void OnModelCreating(ModelBuilder modelBuilder)
         {
             x.ToJson();
             //x.ToJson("xxx").HasColumnType("json");
-            //x.ComplexProperty(y => y.Location, y =>
-            //{
-            //    y.ToJson();
-            //    //y.ToJson("xxx").HasColumnType("json");
-            //});
+            x.ComplexProperty(y => y.Location, y =>
+            {
+                y.HasJsonPropertyName("xxx");
+            });
         });
 
         base.OnModelCreating(modelBuilder);

src/EntityFrameworkCore.SqlServer.SimpleBulks.Tests/DbContextExtensions/GetPropertiesTests.cs

@@ -1,6 +1,8 @@
 using EntityFrameworkCore.SqlServer.SimpleBulks.Extensions;
 using EntityFrameworkCore.SqlServer.SimpleBulks.Tests.Database;
 using Microsoft.EntityFrameworkCore.Metadata;
+using System.Text;
+using System.Text.Json;
 
 namespace EntityFrameworkCore.SqlServer.SimpleBulks.Tests.DbContextExtensions;
 
@@ -282,5 +284,96 @@ public void GetProperties_JsonComplexType_ReturnsCorrectColumnInformation()
         Assert.False(property.IsPrimaryKey);
         Assert.False(property.IsRowVersion);
         Assert.True(property.IsJson);
+        Assert.NotNull(property.JsonPropertyWriters);
+
+        // Verify that the JsonPropertyWriters have correct structure
+        var writers = property.JsonPropertyWriters;
+        Assert.Equal(2, writers.Count); // Street and Location
+
+        var streetWriter = writers.FirstOrDefault(w => w.ClrPropertyName == "Street");
+        Assert.NotNull(streetWriter);
+        Assert.Equal("Street", streetWriter.JsonPropertyName);
+        Assert.Equal(typeof(string), streetWriter.PropertyType);
+        Assert.False(streetWriter.IsNestedComplexType);
+
+        var locationWriter = writers.FirstOrDefault(w => w.ClrPropertyName == "Location");
+        Assert.NotNull(locationWriter);
+        Assert.Equal("xxx", locationWriter.JsonPropertyName); // Mapped to "xxx" in TestDbContext
+        Assert.Equal(typeof(ComplexTypeLocation), locationWriter.PropertyType);
+        Assert.True(locationWriter.IsNestedComplexType);
+        Assert.NotNull(locationWriter.NestedProperties);
+        Assert.Equal(2, locationWriter.NestedProperties.Count); // Lat and Lng
+
+        var latWriter = locationWriter.NestedProperties.FirstOrDefault(w => w.ClrPropertyName == "Lat");
+        Assert.NotNull(latWriter);
+        Assert.Equal(typeof(double), latWriter.PropertyType);
+
+        var lngWriter = locationWriter.NestedProperties.FirstOrDefault(w => w.ClrPropertyName == "Lng");
+        Assert.NotNull(lngWriter);
+        Assert.Equal(typeof(double), lngWriter.PropertyType);
+
+        // Verify serialization using JsonPropertyWriters
+        var testAddress = new ComplexTypeAddress
+        {
+            Street = "123 Main St",
+            Location = new ComplexTypeLocation
+            {
+                Lat = 40.7128,
+                Lng = -74.0060
+            }
+        };
+
+        var json = SerializeWithJsonPropertyWriters(testAddress, writers);
+        Assert.NotNull(json);
+        Assert.Contains("Street", json);
+        Assert.Contains("123 Main St", json);
+        Assert.Contains("xxx", json); // Location is mapped to "xxx"
+        Assert.Contains("Lat", json);
+        Assert.Contains("Lng", json);
+    }
+
+    private static string SerializeWithJsonPropertyWriters(object obj, IReadOnlyList<JsonPropertyWriter> writers)
+    {
+        using var stream = new MemoryStream();
+        using var writer = new Utf8JsonWriter(stream);
+
+        WriteObject(writer, obj, writers);
+
+        writer.Flush();
+        return Encoding.UTF8.GetString(stream.ToArray());
+    }
+
+    private static void WriteObject(Utf8JsonWriter writer, object obj, IReadOnlyList<JsonPropertyWriter> propertyWriters)
+    {
+        writer.WriteStartObject();
+
+        var type = obj.GetType();
+        foreach (var propWriter in propertyWriters)
+        {
+            var propInfo = type.GetProperty(propWriter.ClrPropertyName);
+            if (propInfo == null) continue;
+
+            var value = propInfo.GetValue(obj);
+
+            writer.WritePropertyName(propWriter.JsonPropertyName);
+
+            if (propWriter.IsNestedComplexType)
+            {
+                if (value == null)
+                {
+                    writer.WriteNullValue();
+                }
+                else
+                {
+                    WriteObject(writer, value, propWriter.NestedProperties);
+                }
+            }
+            else
+            {
+                propWriter.WriteValue(writer, value);
+            }
+        }
+
+        writer.WriteEndObject();
     }
 }

src/EntityFrameworkCore.SqlServer.SimpleBulks/ColumnInfor.cs

@@ -1,5 +1,8 @@
 using Microsoft.EntityFrameworkCore.Metadata;
+using Microsoft.EntityFrameworkCore.Storage.Json;
 using System;
+using System.Collections.Generic;
+using System.Text.Json;
 
 namespace EntityFrameworkCore.SqlServer.SimpleBulks;
 
@@ -24,4 +27,40 @@ public class ColumnInfor
     public ValueConverter? ValueConverter { get; set; }
 
     public bool IsJson { get; set; }
+
+    public IReadOnlyList<JsonPropertyWriter>? JsonPropertyWriters { get; init; }
+}
+
+public class JsonPropertyWriter
+{
+    public string JsonPropertyName { get; init; }
+
+    public string ClrPropertyName { get; init; }
+
+    public Type PropertyType { get; init; }
+
+    public JsonValueReaderWriter? ReaderWriter { get; init; }
+
+    public IReadOnlyList<JsonPropertyWriter>? NestedProperties { get; init; }
+
+    public bool IsNestedComplexType => NestedProperties != null && NestedProperties.Count > 0;
+
+    public void WriteValue(Utf8JsonWriter writer, object? value)
+    {
+        if (value == null)
+        {
+            writer.WriteNullValue();
+            return;
+        }
+
+        if (ReaderWriter != null)
+        {
+            ReaderWriter.ToJson(writer, value);
+        }
+        else
+        {
+            // Fallback to System.Text.Json for types without a specific JsonValueReaderWriter
+            JsonSerializer.Serialize(writer, value, PropertyType);
+        }
+    }
 }

src/EntityFrameworkCore.SqlServer.SimpleBulks/Extensions/DbContextExtensions.cs

@@ -150,7 +150,14 @@ public static IReadOnlyList<ColumnInfor> GetProperties(this DbContext dbContext,
                     continue;
                 }
 
-                AddOwnedProperty(data, ownedProperty.TargetEntityType, tableId, ownedProperty.Name + ".");
+                if (ownedProperty.TargetEntityType.IsMappedToJson())
+                {
+
+                }
+                else
+                {
+                    AddOwnedProperty(data, ownedProperty.TargetEntityType, tableId, ownedProperty.Name + ".");
+                }
             }
 
             return data;
@@ -185,6 +192,9 @@ private static void AddJsonComplexProperty(List<ColumnInfor> columnInfors, IComp
         var containerColumnName = complexProperty.ComplexType.GetContainerColumnName();
         var containerColumnType = complexProperty.ComplexType.GetContainerColumnType() ?? "nvarchar(max)";
 
+        // Build JsonPropertyWriters using EF Core's GetJsonValueReaderWriter for each property
+        var jsonPropertyWriters = BuildJsonPropertyWriters(complexProperty.ComplexType);
+
         columnInfors.Add(new ColumnInfor
         {
             PropertyName = complexProperty.Name,
@@ -196,10 +206,50 @@ private static void AddJsonComplexProperty(List<ColumnInfor> columnInfors, IComp
             IsPrimaryKey = false,
             IsRowVersion = false,
             ValueConverter = null,
-            IsJson = true
+            IsJson = true,
+            JsonPropertyWriters = jsonPropertyWriters
         });
     }
 
+    private static List<JsonPropertyWriter> BuildJsonPropertyWriters(IComplexType complexType)
+    {
+        var writers = new List<JsonPropertyWriter>();
+
+        // Add writers for scalar properties
+        foreach (var property in complexType.GetProperties())
+        {
+            var jsonPropertyName = property.GetJsonPropertyName() ?? property.Name;
+            var readerWriter = property.GetJsonValueReaderWriter() ?? property.GetTypeMapping().JsonValueReaderWriter;
+
+            writers.Add(new JsonPropertyWriter
+            {
+                JsonPropertyName = jsonPropertyName,
+                ClrPropertyName = property.Name,
+                PropertyType = property.ClrType,
+                ReaderWriter = readerWriter,
+                NestedProperties = null
+            });
+        }
+
+        // Add writers for nested complex properties
+        foreach (var nestedComplexProperty in complexType.GetComplexProperties())
+        {
+            var jsonPropertyName = nestedComplexProperty.GetJsonPropertyName() ?? nestedComplexProperty.Name;
+            var nestedWriters = BuildJsonPropertyWriters(nestedComplexProperty.ComplexType);
+
+            writers.Add(new JsonPropertyWriter
+            {
+                JsonPropertyName = jsonPropertyName,
+                ClrPropertyName = nestedComplexProperty.Name,
+                PropertyType = nestedComplexProperty.ClrType,
+                ReaderWriter = null,
+                NestedProperties = nestedWriters
+            });
+        }
+
+        return writers;
+    }
+
     private static void AddComplexProperty(List<ColumnInfor> columnInfors, IComplexProperty complexProperty, StoreObjectIdentifier storeObjectIdentifier, string prefix = "")
     {
         var entityProperties = complexProperty.ComplexType.GetProperties();