Merge pull request #5 from magiccodingman/magiccodingman/jsonfix

yueyinqiu · web-flow · commit 083aacb600c5 · 2025-02-26T13:56:23.000+08:00
Magiccodingman/jsonfix
diff --git a/Magic.IndexedDb/Helpers/ExpandoToTypeConverter.cs b/Magic.IndexedDb/Helpers/ExpandoToTypeConverter.cs
@@ -0,0 +1,90 @@
+﻿using System.Dynamic;
+using System.Linq.Expressions;
+
+namespace Magic.IndexedDb.Helpers
+{
+    public static class ExpandoToTypeConverter<T>
+    {
+        private static readonly Dictionary<string, Action<T, object?>> PropertySetters = new();
+        private static readonly Dictionary<Type, bool> NonConcreteTypeCache = new();
+
+        private static readonly bool IsConcrete;
+        private static readonly bool HasParameterlessConstructor;
+
+        static ExpandoToTypeConverter()
+        {
+            Type type = typeof(T);
+            IsConcrete = !(type.IsAbstract || type.IsInterface);
+            HasParameterlessConstructor = type.GetConstructor(Type.EmptyTypes) != null;
+
+            if (IsConcrete && HasParameterlessConstructor)
+            {
+                PrecomputePropertySetters(type);
+            }
+        }
+
+        private static void PrecomputePropertySetters(Type type)
+        {
+            foreach (var prop in type.GetProperties().Where(p => p.CanWrite))
+            {
+                var targetExp = Expression.Parameter(type);
+                var valueExp = Expression.Parameter(typeof(object));
+
+                var convertedValueExp = Expression.Convert(valueExp, prop.PropertyType);
+
+                var propertySetterExp = Expression.Lambda<Action<T, object?>>(
+                    Expression.Assign(Expression.Property(targetExp, prop), convertedValueExp),
+                    targetExp, valueExp
+                );
+
+                PropertySetters[prop.Name] = propertySetterExp.Compile();
+            }
+        }
+
+        public static T ConvertExpando(ExpandoObject expando)
+        {
+            Type type = typeof(T);
+
+            if (IsConcrete && HasParameterlessConstructor)
+            {
+                // Use the fastest method: Precomputed property setters
+                var instance = Activator.CreateInstance<T>();
+                var expandoDict = (IDictionary<string, object?>)expando;
+
+                foreach (var kvp in expandoDict)
+                {
+                    if (PropertySetters.TryGetValue(kvp.Key, out var setter))
+                    {
+                        setter(instance, kvp.Value);
+                    }
+                }
+
+                return instance;
+            }
+            else if (IsConcrete) // Concrete class without a parameterless constructor
+            {
+                var instance = Activator.CreateInstance(type);
+                MagicSerializationHelper.PopulateObject(MagicSerializationHelper.SerializeObject(expando), instance);
+                return (T)instance!;
+            }
+            else
+            {
+                // Last resort: If `T` is an interface or abstract class, fall back to full JSON deserialization
+                var instance = MagicSerializationHelper.DeserializeObject<T>(MagicSerializationHelper.SerializeObject(expando))!;
+
+                // Check if we can cache this as a known type
+                if (!NonConcreteTypeCache.ContainsKey(type))
+                {
+                    NonConcreteTypeCache[type] = true;
+
+                    // Dynamically compute property setters for this type
+                    PrecomputePropertySetters(type);
+                }
+
+                return instance;
+            }
+        }
+    }
+
+
+}
diff --git a/Magic.IndexedDb/Helpers/MagicSerializationHelper.cs b/Magic.IndexedDb/Helpers/MagicSerializationHelper.cs
@@ -0,0 +1,55 @@
+﻿using Magic.IndexedDb.Models;
+using System.Text.Json;
+
+namespace Magic.IndexedDb.Helpers
+{
+    /// <summary>
+    /// Helper to serialize between the Magic Library content to the JS. To communicate with Dexie.JS - 
+    /// Note I left this public only to allow it to be targeted by external projects for testing.
+    /// </summary>
+    public static class MagicSerializationHelper
+    {
+        public static string SerializeObject<T>(T value, MagicJsonSerializationSettings? settings = null)
+        {
+            if (settings == null)
+                settings = new MagicJsonSerializationSettings();
+
+            if (value == null)
+                throw new ArgumentNullException(nameof(value), "Object cannot be null");
+
+            var options = settings.GetOptionsWithResolver<T>(); // Ensure the correct resolver is applied
+
+            return JsonSerializer.Serialize(value, options);
+        }
+
+        public static T? DeserializeObject<T>(string json, MagicJsonSerializationSettings? settings = null)
+        {
+            if (string.IsNullOrWhiteSpace(json))
+                throw new ArgumentException("JSON cannot be null or empty.", nameof(json));
+
+            if (settings == null)
+                settings = new MagicJsonSerializationSettings();
+
+            var options = settings.GetOptionsWithResolver<T>(); // Ensure correct resolver for deserialization
+
+            return JsonSerializer.Deserialize<T>(json, options);
+        }
+
+        public static void PopulateObject<T>(T source, T target)
+        {
+            if (source == null || target == null)
+                throw new ArgumentNullException("Source and target cannot be null");
+
+            var json = JsonSerializer.Serialize(source);
+            var deserialized = JsonSerializer.Deserialize<T>(json);
+
+            foreach (var prop in typeof(T).GetProperties())
+            {
+                var value = prop.GetValue(deserialized);
+                prop.SetValue(target, value);
+            }
+        }
+    }
+
+
+}
diff --git a/Magic.IndexedDb/IndexDbManager.cs b/Magic.IndexedDb/IndexDbManager.cs
@@ -7,9 +7,7 @@
 using Magic.IndexedDb.Models;
 using Magic.IndexedDb.SchemaAnnotations;
 using Microsoft.JSInterop;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using Newtonsoft.Json.Serialization;
+using System.Text.Json.Nodes;
 
 namespace Magic.IndexedDb
 {
@@ -233,9 +231,9 @@ public async Task AddRangeAsync<T>(
                 T? myClass = null;
 
                 object? processedRecord = await ProcessRecordAsync(record, cancellationToken);
-                if (processedRecord is ExpandoObject)
+                if (processedRecord is ExpandoObject expando)
                 {
-                    myClass = JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(processedRecord));
+                    myClass = ExpandoToTypeConverter<T>.ConvertExpando(expando);
                     IsExpando = true;
                 }
                 else
@@ -376,7 +374,6 @@ public MagicQuery<T> Where<T>(Expression<Func<T, bool>> predicate) where T : cla
 
             // Preprocess the predicate to break down Any and All expressions
             var preprocessedPredicate = PreprocessPredicate(predicate);
-            var asdf = preprocessedPredicate.ToString();
             CollectBinaryExpressions(preprocessedPredicate.Body, preprocessedPredicate, query.JsonQueries);
 
             return query;
@@ -397,7 +394,7 @@ private Expression<Func<T, bool>> PreprocessPredicate<T>(Expression<Func<T, bool
             string? jsonQueryAdditions = null;
             if (query != null && query.storedMagicQueries != null && query.storedMagicQueries.Count > 0)
             {
-                jsonQueryAdditions = Newtonsoft.Json.JsonConvert.SerializeObject(query.storedMagicQueries.ToArray());
+                jsonQueryAdditions = MagicSerializationHelper.SerializeObject(query.storedMagicQueries.ToArray());
             }
             var propertyMappings = ManagerHelper.GeneratePropertyMapping<T>();
             IList<Dictionary<string, object>>? ListToConvert =
@@ -510,9 +507,13 @@ private TRecord ConvertIndexedDbRecordToCRecord<TRecord>(Dictionary<string, obje
 
         private string GetJsonQueryFromExpression<T>(Expression<Func<T, bool>> predicate) where T : class
         {
-            var serializerSettings = new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() };
-            var conditions = new List<JObject>();
-            var orConditions = new List<List<JObject>>();
+            var serializerSettings = new MagicJsonSerializationSettings
+            {
+                UseCamelCase = true // Equivalent to setting CamelCasePropertyNamesContractResolver
+            };
+
+            var conditions = new List<JsonObject>();
+            var orConditions = new List<List<JsonObject>>();
 
             void TraverseExpression(Expression expression, bool inOrBranch = false)
             {
@@ -656,14 +657,14 @@ void AddConditionInternal(MemberExpression? left, ConstantExpression? right, str
                             columnName = propertyInfo.GetPropertyColumnName<MagicPrimaryKeyAttribute>();
 
                         bool _isString = false;
-                        JToken? valSend = null;
+                        JsonNode? valSend = null;
                         if (right != null && right.Value != null)
                         {
-                            valSend = JToken.FromObject(right.Value);
+                            valSend = JsonValue.Create(right.Value);
                             _isString = right.Value is string;
                         }
 
-                        var jsonCondition = new JObject
+                        var jsonCondition = new JsonObject
             {
                 { "property", columnName },
                 { "operation", operation },
@@ -677,7 +678,7 @@ void AddConditionInternal(MemberExpression? left, ConstantExpression? right, str
                             var currentOrConditions = orConditions.LastOrDefault();
                             if (currentOrConditions == null)
                             {
-                                currentOrConditions = new List<JObject>();
+                                currentOrConditions = new List<JsonObject>();
                                 orConditions.Add(currentOrConditions);
                             }
                             currentOrConditions.Add(jsonCondition);
@@ -697,7 +698,7 @@ void AddConditionInternal(MemberExpression? left, ConstantExpression? right, str
                 orConditions.Add(conditions);
             }
 
-            return JsonConvert.SerializeObject(orConditions, serializerSettings);
+            return MagicSerializationHelper.SerializeObject(orConditions, serializerSettings);
         }
 
         /// <summary>
diff --git a/Magic.IndexedDb/Magic.IndexedDb.csproj b/Magic.IndexedDb/Magic.IndexedDb.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk.Razor">
+﻿<Project Sdk="Microsoft.NET.Sdk.Razor">
 
   <PropertyGroup>
     <TargetFramework>net8.0</TargetFramework>
@@ -43,7 +43,6 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.Components.Web" Version="8.0.11" />
-    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
   </ItemGroup>
 
 </Project>
diff --git a/Magic.IndexedDb/Models/CustomContractResolver.cs b/Magic.IndexedDb/Models/CustomContractResolver.cs
diff --git a/Magic.IndexedDb/Models/MagicContractResolver.cs b/Magic.IndexedDb/Models/MagicContractResolver.cs
@@ -0,0 +1,103 @@
+﻿using Magic.IndexedDb.SchemaAnnotations;
+using System.Collections.Concurrent;
+using System.Reflection;
+using System.Text.Json.Serialization;
+using System.Text.Json;
+using System.Collections;
+
+namespace Magic.IndexedDb.Models
+{
+    internal class MagicContractResolver<T> : JsonConverter<T>
+    {
+        private static readonly ConcurrentDictionary<MemberInfo, bool> _cachedIgnoredProperties = new();
+
+        public override T? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            // Defer deserialization back to built-in handling to ensure correctness
+            return JsonSerializer.Deserialize<T>(ref reader, options);
+        }
+
+        public override void Write(Utf8JsonWriter writer, T value, JsonSerializerOptions options)
+        {
+            if (value == null)
+            {
+                writer.WriteNullValue();
+                return;
+            }
+
+            // Handle simple or primitive types directly
+            if (IsSimpleType(typeof(T)))
+            {
+                JsonSerializer.Serialize(writer, value, options);
+                return;
+            }
+
+            // Handle collections
+            if (value is IEnumerable enumerable && typeof(T) != typeof(string))
+            {
+                writer.WriteStartArray();
+                foreach (var item in enumerable)
+                {
+                    if (item == null)
+                        writer.WriteNullValue();
+                    else
+                        JsonSerializer.Serialize(writer, item, item.GetType(), options);
+                }
+                writer.WriteEndArray();
+                return;
+            }
+
+            // Handle complex objects
+            writer.WriteStartObject();
+            foreach (var property in typeof(T).GetProperties(BindingFlags.Public | BindingFlags.Instance))
+            {
+                if (ShouldIgnoreProperty(property))
+                    continue;
+
+                var propName = options.PropertyNamingPolicy?.ConvertName(property.Name) ?? property.Name;
+
+                if (property.GetIndexParameters().Length > 0)
+                    continue; // Skip indexers entirely
+
+                object? propValue;
+                try
+                {
+                    propValue = property.GetValue(value);
+                }
+                catch
+                {
+                    // Fallback: write null if getting property fails
+                    propValue = null;
+                }
+
+                writer.WritePropertyName(propName);
+                if (propValue == null)
+                    writer.WriteNullValue();
+                else
+                    JsonSerializer.Serialize(writer, propValue, propValue.GetType(), options);
+            }
+            writer.WriteEndObject();
+        }
+
+        private static bool ShouldIgnoreProperty(PropertyInfo property)
+        {
+            return _cachedIgnoredProperties.GetOrAdd(property, prop =>
+                prop.GetCustomAttributes(inherit: true)
+                    .Any(a => a.GetType().FullName == typeof(MagicNotMappedAttribute).FullName));
+        }
+
+        private static bool IsSimpleType(Type type)
+        {
+            return type.IsPrimitive ||
+                   type.IsEnum ||
+                   type == typeof(string) ||
+                   type == typeof(decimal) ||
+                   type == typeof(DateTime) ||
+                   type == typeof(DateTimeOffset) ||
+                   type == typeof(Guid) ||
+                   type == typeof(Uri) ||
+                   type == typeof(TimeSpan);
+        }
+    }
+
+}
diff --git a/Magic.IndexedDb/Models/MagicJsonSerializationSettings.cs b/Magic.IndexedDb/Models/MagicJsonSerializationSettings.cs
