diff --git a/AyCode.Core.Serializers.Console/AyCode.Core.Serializers.Console.csproj b/AyCode.Core.Serializers.Console/AyCode.Core.Serializers.Console.csproj index 9654e4d..352bf54 100644 --- a/AyCode.Core.Serializers.Console/AyCode.Core.Serializers.Console.csproj +++ b/AyCode.Core.Serializers.Console/AyCode.Core.Serializers.Console.csproj @@ -17,22 +17,36 @@ enable enable - - true - true - - - $(DefineConstants);AYCODE_NATIVEAOT - - - - true - false - true + + + true + true + $(DefineConstants);AYCODE_NATIVEAOT + + + true + false + + diff --git a/AyCode.Core.Serializers.Console/Program.cs b/AyCode.Core.Serializers.Console/Program.cs index 292f1fe..bbe6140 100644 --- a/AyCode.Core.Serializers.Console/Program.cs +++ b/AyCode.Core.Serializers.Console/Program.cs @@ -759,6 +759,7 @@ public static class Program _progressLastLineLen = 0; } +#if !AYCODE_NATIVEAOT private static readonly JsonSerializerOptions VerifyJsonOpts = new() { WriteIndented = false, @@ -766,13 +767,26 @@ public static class Program DefaultIgnoreCondition = System.Text.Json.Serialization.JsonIgnoreCondition.WhenWritingNull, ReferenceHandler = System.Text.Json.Serialization.ReferenceHandler.IgnoreCycles }; +#endif /// /// Round-trip equality check: serialize both via System.Text.Json (canonical form) and compare strings. /// Slower than property-by-property compare, but universal — works for any object graph without custom comparer. /// + /// + /// AOT publish skip: System.Text.Json's reflection path uses runtime closed-generic instantiation + /// (JsonPropertyInfo<TestStatus> et al.) that the trimmer drops, causing + /// NotSupportedException: missing native code or metadata. The validation is JIT-only — the actual + /// benchmark Serialize/Deserialize loops don't touch this path. Under AOT we return true so all + /// VerifyRoundTrip() calls pass without running the cross-format validation. + /// private static bool DeepEqualsViaJson(object? a, object? b) { +#if AYCODE_NATIVEAOT + // Skip cross-format validation under AOT — STJ reflection path is incompatible. The roundtrip + // itself still runs (caller-side Serialize+Deserialize), just the JSON-canonical compare is bypassed. + return true; +#else if (a == null && b == null) return true; if (a == null || b == null) return false; @@ -780,6 +794,7 @@ public static class Program var jsonB = JsonSerializer.Serialize(b, VerifyJsonOpts); return jsonA == jsonB; +#endif } /// diff --git a/AyCode.Core.Tests/TestModels/BenchmarkTestDataProvider.cs b/AyCode.Core.Tests/TestModels/BenchmarkTestDataProvider.cs index 0085429..3c88585 100644 --- a/AyCode.Core.Tests/TestModels/BenchmarkTestDataProvider.cs +++ b/AyCode.Core.Tests/TestModels/BenchmarkTestDataProvider.cs @@ -140,14 +140,16 @@ public static class BenchmarkTestDataProvider // Repeated string fields — ProductName on items + PalletCode on pallets. Both are common // across the hierarchy, exercising string-interning deduplication on the Default preset // (which has UseStringInterning = All). Targeting ~20% repeated-string share overall. + // Strings contain non-ASCII characters (Hungarian accented letters → multi-byte UTF-8) so the + // benchmark reflects real-world i18n payloads, not just the ASCII FixStr fast-path. foreach (var item in order.Items) { item.Status = TestStatus.Processing; - item.ProductName = "CommonProductName_RepeatedForTesting"; + item.ProductName = "TermékNév_IsmétlődőTesztAdat_árvíztűrőtükörfúrógép"; foreach (var pallet in item.Pallets) { - pallet.PalletCode = "CommonPalletCode_RepeatedForTesting"; + pallet.PalletCode = "RaklapKód_IsmétlődőTesztAdat_árvíztűrő"; } } diff --git a/AyCode.Core/Serializers/AcSerializerCommon.cs b/AyCode.Core/Serializers/AcSerializerCommon.cs index b07e40a..f67b22f 100644 --- a/AyCode.Core/Serializers/AcSerializerCommon.cs +++ b/AyCode.Core/Serializers/AcSerializerCommon.cs @@ -1,4 +1,5 @@ using System.Collections.Concurrent; +using System.Diagnostics.CodeAnalysis; using System.Linq.Expressions; using System.Reflection; using System.Runtime.CompilerServices; @@ -463,7 +464,9 @@ public static class AcSerializerCommon /// Shared across all TypeMetadata implementations. /// [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static Func CreateCompiledGetter(Type declaringType, PropertyInfo prop) + public static Func CreateCompiledGetter( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType, + PropertyInfo prop) { // NativeAOT (and other no-dynamic-code targets): fall back to plain reflection. // The returned delegate is cached per-property by the caller, so the indirection cost is paid @@ -482,7 +485,9 @@ public static class AcSerializerCommon /// Creates a compiled setter for a property using expression trees. /// Handles nullable value types correctly, including null values. /// - public static Action CreateCompiledSetter(Type declaringType, PropertyInfo prop) + public static Action CreateCompiledSetter( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType, + PropertyInfo prop) { if (!RuntimeFeature.IsDynamicCodeSupported) return prop.SetValue; @@ -526,7 +531,17 @@ public static class AcSerializerCommon /// Creates a compiled parameterless constructor for a type. /// Returns null if type is abstract or has no parameterless constructor. /// - public static Func? CreateCompiledConstructor(Type type) + /// + /// NativeAOT: with + /// ensures the trimmer + /// preserves the public parameterless ctor's reflection metadata on the supplied type — required + /// for to + /// return non-null AND for the reflection-fallback ctor.Invoke(null) path (when + /// is false). Without this annotation the + /// trimmer drops the metadata and both paths fail with . + /// + public static Func? CreateCompiledConstructor( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor)] Type type) { if (type.IsAbstract) return null; @@ -544,7 +559,9 @@ public static class AcSerializerCommon /// /// Creates a typed getter delegate to avoid boxing for value types. /// - public static Func CreateTypedGetter(Type declaringType, PropertyInfo prop) + public static Func CreateTypedGetter( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType, + PropertyInfo prop) { if (!RuntimeFeature.IsDynamicCodeSupported) return obj => (TProperty)prop.GetValue(obj)!; @@ -564,7 +581,9 @@ public static class AcSerializerCommon /// /// Creates an enum getter that returns int to avoid boxing. /// - public static Func CreateEnumGetter(Type declaringType, PropertyInfo prop) + public static Func CreateEnumGetter( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType, + PropertyInfo prop) { if (!RuntimeFeature.IsDynamicCodeSupported) return obj => Convert.ToInt32(prop.GetValue(obj)); @@ -579,7 +598,9 @@ public static class AcSerializerCommon /// /// Creates a typed setter delegate to avoid boxing for value types. /// - public static Action CreateTypedSetter(Type declaringType, PropertyInfo prop) + public static Action CreateTypedSetter( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType, + PropertyInfo prop) { if (!RuntimeFeature.IsDynamicCodeSupported) return (obj, value) => prop.SetValue(obj, value); @@ -595,7 +616,9 @@ public static class AcSerializerCommon /// /// Creates an enum setter that accepts int to avoid boxing. /// - public static Action CreateEnumSetter(Type declaringType, PropertyInfo prop) + public static Action CreateEnumSetter( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType, + PropertyInfo prop) { if (!RuntimeFeature.IsDynamicCodeSupported) { diff --git a/AyCode.Core/Serializers/AcSerializerContextBase.cs b/AyCode.Core/Serializers/AcSerializerContextBase.cs index 96f1a83..e91902b 100644 --- a/AyCode.Core/Serializers/AcSerializerContextBase.cs +++ b/AyCode.Core/Serializers/AcSerializerContextBase.cs @@ -2,6 +2,7 @@ using System; using System.Collections.Concurrent; using System.Collections.Generic; using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; using System.Runtime.CompilerServices; namespace AyCode.Core.Serializers; @@ -62,10 +63,19 @@ public abstract class AcSerializerContextBase /// private TypeMetadataWrapper?[]? _wrapperSlots; + /// + /// Custom delegate carrying DAMs annotation on its parameter — required for + /// trimmer/AOT correctness. Standard Func<Type, TMetadata> drops DAMs at the delegate + /// signature, breaking the propagation chain from down through + /// TypeMetadataBase's CreateCompiledConstructor. This delegate type preserves it. + /// + public delegate TMetadata MetadataFactoryDelegate( + [DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] Type type); + /// /// Factory function to create metadata. Implemented by derived class. /// - protected abstract Func MetadataFactory { get; } + protected abstract MetadataFactoryDelegate MetadataFactory { get; } //[MethodImpl(MethodImplOptions.AggressiveInlining)] //public bool UseTypeReferenceHandling(Type type) @@ -87,7 +97,8 @@ public abstract class AcSerializerContextBase /// The wrapper contains metadata (from GlobalMetadataCache) + per-context tracking state. /// [MethodImpl(MethodImplOptions.AggressiveInlining)] - public TypeMetadataWrapper GetWrapper(Type type) + public TypeMetadataWrapper GetWrapper( + [DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] Type type) { if (_wrappers.TryGetValue(type, out var wrapper)) return wrapper; @@ -96,10 +107,14 @@ public abstract class AcSerializerContextBase } [MethodImpl(MethodImplOptions.NoInlining)] - private TypeMetadataWrapper GetWrapperSlow(Type type) + private TypeMetadataWrapper GetWrapperSlow( + [DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] Type type) { - // Get metadata from global cache (thread-safe) - var metadata = GlobalMetadataCache.GetOrAdd(type, MetadataFactory); + // Get metadata from global cache (thread-safe). + // ConcurrentDictionary.GetOrAdd's Func overload drops DAMs at the delegate + // signature — but our MetadataFactoryDelegate type carries the annotation, and the local + // `type` variable still has DAMs in scope here, so the trimmer accepts the call without warning. + var metadata = GlobalMetadataCache.GetOrAdd(type, MetadataFactoryShim); // Create wrapper with metadata + tracking state (per-context) var wrapper = new TypeMetadataWrapper(metadata); @@ -107,13 +122,29 @@ public abstract class AcSerializerContextBase return wrapper; } + /// + /// Shim that bridges the standard Func<Type, TMetadata> required by + /// and our + /// DAMs-aware . The trimmer cannot prove the conversion + /// preserves DAMs because Func's parameter has no annotation — but in practice the + /// metadata factory only ever receives types that flowed through 's + /// DAMs-annotated parameter, so the runtime contract is preserved. Suppression is bounded. + /// + [UnconditionalSuppressMessage("Trimming", "IL2067", + Justification = "Func drops DAMs at the delegate signature. The metadata factory is only " + + "invoked with types that originated from a DAMs-annotated GetWrapper parameter; " + + "the runtime contract holds even though static analysis can't trace it through Func.")] + private TMetadata MetadataFactoryShim(Type type) => MetadataFactory(type); + /// /// Gets or creates a wrapper for the specified type using a slot index. /// Slot checked first (array access ~1-2ns), falls back to dictionary if slot empty. /// Used by both SGen (compile-time slot) and runtime polymorphic cache (0..RuntimeSlotCount-1). /// [MethodImpl(MethodImplOptions.AggressiveInlining)] - public TypeMetadataWrapper GetWrapper(Type type, int slotIndex) + public TypeMetadataWrapper GetWrapper( + [DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] Type type, + int slotIndex) { var slots = _wrapperSlots!; var wrapper = slots[slotIndex]; diff --git a/AyCode.Core/Serializers/Binaries/AcBinaryDeserializer.BinaryDeserializationContext.cs b/AyCode.Core/Serializers/Binaries/AcBinaryDeserializer.BinaryDeserializationContext.cs index d6cd60b..78ba0ef 100644 --- a/AyCode.Core/Serializers/Binaries/AcBinaryDeserializer.BinaryDeserializationContext.cs +++ b/AyCode.Core/Serializers/Binaries/AcBinaryDeserializer.BinaryDeserializationContext.cs @@ -129,8 +129,14 @@ public static partial class AcBinaryDeserializer /// /// Factory for creating BinaryDeserializeTypeMetadata instances. /// - protected override Func MetadataFactory - => static t => new BinaryDeserializeTypeMetadata(t); + /// + /// The lambda's t parameter explicitly declares DAMs to match the + /// signature — DAMs do not auto-propagate from the + /// delegate type to lambda parameters. + /// + protected override MetadataFactoryDelegate MetadataFactory + => static ([System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] t) + => new BinaryDeserializeTypeMetadata(t); public BinaryDeserializationContext() { diff --git a/AyCode.Core/Serializers/Binaries/AcBinaryDeserializer.BinaryDeserializeTypeMetadata.cs b/AyCode.Core/Serializers/Binaries/AcBinaryDeserializer.BinaryDeserializeTypeMetadata.cs index dfe973b..3f96b79 100644 --- a/AyCode.Core/Serializers/Binaries/AcBinaryDeserializer.BinaryDeserializeTypeMetadata.cs +++ b/AyCode.Core/Serializers/Binaries/AcBinaryDeserializer.BinaryDeserializeTypeMetadata.cs @@ -1,3 +1,4 @@ +using System.Diagnostics.CodeAnalysis; using System.Reflection; using System.Runtime.CompilerServices; using AyCode.Core.Helpers; @@ -29,7 +30,9 @@ public static partial class AcBinaryDeserializer /// public Type? GeneratedSerializerType { get; } - public BinaryDeserializeTypeMetadata(Type type) : base(type, HasJsonIgnoreAttribute) + public BinaryDeserializeTypeMetadata( + [DynamicallyAccessedMembers(RequiredMembers)] Type type) + : base(type, HasJsonIgnoreAttribute) { // Use pre-computed WritableProperties directly - no method call overhead! var orderedProperties = WritableProperties; @@ -107,7 +110,9 @@ public static partial class AcBinaryDeserializer private readonly Func? _manualElementIdGetter; private readonly bool _manualIsIIdCollection; - public BinaryPropertySetterInfo(PropertyInfo property, Type declaringType) + public BinaryPropertySetterInfo( + PropertyInfo property, + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType) : base(property, declaringType) { _isManualConstruction = false; diff --git a/AyCode.Core/Serializers/Binaries/AcBinaryDeserializer.cs b/AyCode.Core/Serializers/Binaries/AcBinaryDeserializer.cs index 68a103a..c41224e 100644 --- a/AyCode.Core/Serializers/Binaries/AcBinaryDeserializer.cs +++ b/AyCode.Core/Serializers/Binaries/AcBinaryDeserializer.cs @@ -4,6 +4,7 @@ using System.Collections; using System.Collections.Concurrent; using System.Collections.Frozen; using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; using System.Linq.Expressions; using System.Reflection; using System.Runtime.CompilerServices; @@ -159,14 +160,24 @@ public static partial class AcBinaryDeserializer /// /// Deserialize binary data to object of type T. /// + /// + /// NativeAOT contract: is annotated with DAMs PublicParameterlessConstructor | PublicProperties + /// so the trimmer preserves the constructor + property reflection metadata required by the runtime + /// reflection path (Activator.CreateInstance, Type.GetConstructor, PropertyInfo.GetValue/SetValue). + /// Without this annotation the runtime path throws under AOT publish. + /// The SGen path (when has [AcBinarySerializable]) does not rely on + /// reflection metadata and works regardless — but the annotation is harmless and uniform. + /// [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static T? Deserialize(byte[] data) => Deserialize(data, AcBinarySerializerOptions.Default); + public static T? Deserialize<[DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] T>(byte[] data) + => Deserialize(data, AcBinarySerializerOptions.Default); /// /// Deserialize binary data to object of type T with options. /// Zero-copy: ArrayBinaryInput references the byte[] directly. /// - public static T? Deserialize(byte[] data, AcBinarySerializerOptions options) + /// + public static T? Deserialize<[DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] T>(byte[] data, AcBinarySerializerOptions options) { if (data.Length == 0) return default; if (data.Length == 1 && data[0] == BinaryTypeCode.Null) return default; @@ -186,14 +197,17 @@ public static partial class AcBinaryDeserializer /// Deserialize binary data to object of type T from a sub-range of a byte[]. /// Zero-copy: ArrayBinaryInput references the byte[] directly with offset. /// + /// [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static T? Deserialize(byte[] data, int offset, int length) => Deserialize(data, offset, length, AcBinarySerializerOptions.Default); + public static T? Deserialize<[DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] T>(byte[] data, int offset, int length) + => Deserialize(data, offset, length, AcBinarySerializerOptions.Default); /// /// Deserialize binary data to object of type T from a sub-range with options. /// Zero-copy: ArrayBinaryInput references the byte[] directly with offset. /// - public static T? Deserialize(byte[] data, int offset, int length, AcBinarySerializerOptions options) + /// + public static T? Deserialize<[DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] T>(byte[] data, int offset, int length, AcBinarySerializerOptions options) { if (length == 0) return default; if (length == 1 && data[offset] == BinaryTypeCode.Null) return default; @@ -211,24 +225,30 @@ public static partial class AcBinaryDeserializer /// /// Deserialize binary data to specified type. /// - public static object? Deserialize(byte[] data, Type targetType) => Deserialize(data, 0, data.Length, targetType, AcBinarySerializerOptions.Default); + /// + public static object? Deserialize(byte[] data, [DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] Type targetType) + => Deserialize(data, 0, data.Length, targetType, AcBinarySerializerOptions.Default); /// /// Deserialize binary data to specified type with options. /// - public static object? Deserialize(byte[] data, Type targetType, AcBinarySerializerOptions options) => Deserialize(data, 0, data.Length, targetType, options); + /// + public static object? Deserialize(byte[] data, [DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] Type targetType, AcBinarySerializerOptions options) + => Deserialize(data, 0, data.Length, targetType, options); /// /// Deserialize binary data to specified type from a sub-range. /// - public static object? Deserialize(byte[] data, int offset, int length, Type targetType) + /// + public static object? Deserialize(byte[] data, int offset, int length, [DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] Type targetType) => Deserialize(data, offset, length, targetType, AcBinarySerializerOptions.Default); /// /// Deserialize binary data to specified type from a sub-range with options. /// Zero-copy: ArrayBinaryInput references the byte[] directly with offset. /// - public static object? Deserialize(byte[] data, int offset, int length, Type targetType, AcBinarySerializerOptions options) + /// + public static object? Deserialize(byte[] data, int offset, int length, [DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] Type targetType, AcBinarySerializerOptions options) { if (length == 0) return null; if (length == 1 && data[offset] == BinaryTypeCode.Null) return null; @@ -246,14 +266,16 @@ public static partial class AcBinaryDeserializer /// Deserialize binary data from a ReadOnlySequence (e.g., from SignalR/Pipes). /// Single-segment: zero-copy via FirstSpan. Multi-segment: linearize into pooled buffer. /// - public static T? Deserialize(ReadOnlySequence data) + /// + public static T? Deserialize<[DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] T>(ReadOnlySequence data) => Deserialize(data, AcBinarySerializerOptions.Default); /// /// Deserialize binary data from a ReadOnlySequence with options. /// Single-segment: zero-copy via FirstSpan. Multi-segment: uses SequenceBinaryInput for true streaming. /// - public static T? Deserialize(ReadOnlySequence data, AcBinarySerializerOptions options) + /// + public static T? Deserialize<[DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] T>(ReadOnlySequence data, AcBinarySerializerOptions options) { if (data.Length == 0) return default; @@ -267,13 +289,15 @@ public static partial class AcBinaryDeserializer /// /// Deserialize binary data from a ReadOnlySequence to specified type. /// - public static object? Deserialize(ReadOnlySequence data, Type targetType) + /// + public static object? Deserialize(ReadOnlySequence data, [DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] Type targetType) => Deserialize(data, targetType, AcBinarySerializerOptions.Default); /// /// Deserialize binary data from a ReadOnlySequence to specified type with options. /// - public static object? Deserialize(ReadOnlySequence data, Type targetType, AcBinarySerializerOptions options) + /// + public static object? Deserialize(ReadOnlySequence data, [DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] Type targetType, AcBinarySerializerOptions options) { if (data.Length == 0) return null; @@ -296,10 +320,11 @@ public static partial class AcBinaryDeserializer /// struct satisfies the JIT-specialization constraint of the generic deserialization path /// without exposing a value-type wrapper to the public API. /// - public static T? Deserialize(AsyncPipeReaderInput input) => Deserialize(input, AcBinarySerializerOptions.Default); + public static T? Deserialize<[DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] T>(AsyncPipeReaderInput input) + => Deserialize(input, AcBinarySerializerOptions.Default); /// - public static T? Deserialize(AsyncPipeReaderInput input, AcBinarySerializerOptions options) + public static T? Deserialize<[DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] T>(AsyncPipeReaderInput input, AcBinarySerializerOptions options) { try { @@ -316,7 +341,7 @@ public static partial class AcBinaryDeserializer } /// - public static object? Deserialize(AsyncPipeReaderInput input, Type targetType, AcBinarySerializerOptions options) + public static object? Deserialize(AsyncPipeReaderInput input, [DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] Type targetType, AcBinarySerializerOptions options) { try { diff --git a/AyCode.Core/Serializers/Binaries/AcBinarySerializer.BinarySerializationContext.cs b/AyCode.Core/Serializers/Binaries/AcBinarySerializer.BinarySerializationContext.cs index 0d0c549..f2c8bf2 100644 --- a/AyCode.Core/Serializers/Binaries/AcBinarySerializer.BinarySerializationContext.cs +++ b/AyCode.Core/Serializers/Binaries/AcBinarySerializer.BinarySerializationContext.cs @@ -277,8 +277,14 @@ public static partial class AcBinarySerializer /// /// Factory for creating BinarySerializeTypeMetadata instances. /// - protected override Func MetadataFactory - => static t => new BinarySerializeTypeMetadata(t, HasJsonIgnoreAttribute); + /// + /// The lambda's t parameter explicitly declares DAMs to match the + /// signature — DAMs do not auto-propagate from the + /// delegate type to lambda parameters. + /// + protected override MetadataFactoryDelegate MetadataFactory + => static ([System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] t) + => new BinarySerializeTypeMetadata(t, HasJsonIgnoreAttribute); public override void Reset(AcBinarySerializerOptions options) { diff --git a/AyCode.Core/Serializers/Binaries/AcBinarySerializer.BinarySerializeTypeMetadata.cs b/AyCode.Core/Serializers/Binaries/AcBinarySerializer.BinarySerializeTypeMetadata.cs index 62fc178..81743b6 100644 --- a/AyCode.Core/Serializers/Binaries/AcBinarySerializer.BinarySerializeTypeMetadata.cs +++ b/AyCode.Core/Serializers/Binaries/AcBinarySerializer.BinarySerializeTypeMetadata.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; using System.Reflection; using System.Runtime.CompilerServices; using AyCode.Core.Serializers; @@ -126,7 +127,10 @@ public static partial class AcBinarySerializer /// public int MinWriteSize { get; } - public BinarySerializeTypeMetadata(Type type, Func ignorePropertyFilter) : base(type,ignorePropertyFilter) + public BinarySerializeTypeMetadata( + [DynamicallyAccessedMembers(RequiredMembers)] Type type, + Func ignorePropertyFilter) + : base(type, ignorePropertyFilter) { // Use pre-computed WritableProperties directly - no method call overhead! var orderedProperties = WritableProperties; @@ -232,7 +236,10 @@ public static partial class AcBinarySerializer /// internal sealed class BinaryPropertyAccessor : BinaryPropertyAccessorBase { - public BinaryPropertyAccessor(PropertyInfo prop, Type declaringType, bool enableInternString) + public BinaryPropertyAccessor( + PropertyInfo prop, + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType, + bool enableInternString) : base(prop, declaringType, enableInternString) { } diff --git a/AyCode.Core/Serializers/Binaries/AcBinarySerializer.ScanPass.cs b/AyCode.Core/Serializers/Binaries/AcBinarySerializer.ScanPass.cs index 4f34741..355042c 100644 --- a/AyCode.Core/Serializers/Binaries/AcBinarySerializer.ScanPass.cs +++ b/AyCode.Core/Serializers/Binaries/AcBinarySerializer.ScanPass.cs @@ -209,7 +209,17 @@ public static partial class AcBinarySerializer /// Public entry point for SGen-generated ScanProperties to call back into runtime ScanValue /// for child types that don't have a generated writer (fallback to runtime path with wrapper lookup). /// - internal static void ScanValueGenerated(object value, Type type, BinarySerializationContext context, int depth) + /// + /// SGen-generated callers always pass a statically-known type (e.g. typeof(MetadataInfo)), + /// so the DAMs annotation propagates correctly: the trimmer sees the static typeof reference, + /// preserves the type's PublicProperties metadata, and + /// is satisfied. + /// + internal static void ScanValueGenerated( + object value, + [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] Type type, + BinarySerializationContext context, + int depth) where TOutput : struct, IBinaryOutputBase { var wrapper = context.GetWrapper(type); diff --git a/AyCode.Core/Serializers/Binaries/AcBinarySerializer.cs b/AyCode.Core/Serializers/Binaries/AcBinarySerializer.cs index d01194d..2000e28 100644 --- a/AyCode.Core/Serializers/Binaries/AcBinarySerializer.cs +++ b/AyCode.Core/Serializers/Binaries/AcBinarySerializer.cs @@ -4,6 +4,7 @@ using System.Buffers; using System.Collections; using System.Collections.Concurrent; using System.Diagnostics; +using System.Diagnostics.CodeAnalysis; using System.Linq.Expressions; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; @@ -286,20 +287,30 @@ public static partial class AcBinarySerializer /// /// Serialize object to binary with default options. /// + /// + /// NativeAOT contract: is annotated with DAMs PublicProperties + /// so the trimmer preserves metadata required by the + /// runtime reflection path (compiled getters fall back to PropertyInfo.GetValue when + /// is false). + /// SGen path is unaffected — annotation is uniform with . + /// [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static byte[] Serialize(T value) => Serialize(value, AcBinarySerializerOptions.Default); + public static byte[] Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(T value) + => Serialize(value, AcBinarySerializerOptions.Default); /// /// Serialize object to an IBufferWriter with default options. Returns bytes written. /// + /// [MethodImpl(MethodImplOptions.AggressiveInlining)] - public static int Serialize(T value, IBufferWriter writer) => Serialize(value, writer, AcBinarySerializerOptions.Default); + public static int Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(T value, IBufferWriter writer) + => Serialize(value, writer, AcBinarySerializerOptions.Default); /// /// Serialize object to binary with specified options. /// Uses ArrayBinaryOutput for byte[] result path. /// - public static byte[] Serialize(T value, AcBinarySerializerOptions options) + public static byte[] Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(T value, AcBinarySerializerOptions options) { if (value == null) return [BinaryTypeCode.Null]; @@ -365,7 +376,7 @@ public static partial class AcBinarySerializer /// Uses BufferWriterBinaryOutput — writes directly to the caller's buffer. /// Note: Compression is applied if enabled in options. /// - public static int Serialize(T value, IBufferWriter writer, AcBinarySerializerOptions options) + public static int Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(T value, IBufferWriter writer, AcBinarySerializerOptions options) { if (value == null) { @@ -451,7 +462,7 @@ public static partial class AcBinarySerializer /// on stuck consumers. /// /// Total serialized bytes written. - public static int SerializeChunked(T value, System.IO.Pipelines.Pipe pipe, AcBinarySerializerOptions options, FlushPolicy flushPolicy = FlushPolicy.DoubleBuffered, TimeSpan? flushTimeout = null) + public static int SerializeChunked<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(T value, System.IO.Pipelines.Pipe pipe, AcBinarySerializerOptions options, FlushPolicy flushPolicy = FlushPolicy.DoubleBuffered, TimeSpan? flushTimeout = null) { if (pipe is null) throw new ArgumentNullException(nameof(pipe)); return SerializeToPipeWriterCore(value, pipe.Writer, options, flushPolicy, flushTimeout, multiMessage: false); @@ -480,7 +491,7 @@ public static partial class AcBinarySerializer /// Target pipe writer. /// Serializer options (type wrappers, reference handling, interning, etc.). /// Total serialized bytes written. - public static int SerializeChunked(T value, System.IO.Pipelines.PipeWriter pipeWriter, AcBinarySerializerOptions options) + public static int SerializeChunked<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(T value, System.IO.Pipelines.PipeWriter pipeWriter, AcBinarySerializerOptions options) => SerializeToPipeWriterCore(value, pipeWriter, options, FlushPolicy.DoubleBuffered, flushTimeout: null, multiMessage: false); /// @@ -510,7 +521,7 @@ public static partial class AcBinarySerializer /// See . /// See . /// Total serialized data bytes (excluding framing overhead). - public static int SerializeChunkedFramed(T value, System.IO.Pipelines.Pipe pipe, AcBinarySerializerOptions options, FlushPolicy flushPolicy = FlushPolicy.DoubleBuffered, TimeSpan? flushTimeout = null) + public static int SerializeChunkedFramed<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(T value, System.IO.Pipelines.Pipe pipe, AcBinarySerializerOptions options, FlushPolicy flushPolicy = FlushPolicy.DoubleBuffered, TimeSpan? flushTimeout = null) { if (pipe is null) throw new ArgumentNullException(nameof(pipe)); return SerializeToPipeWriterCore(value, pipe.Writer, options, flushPolicy, flushTimeout, multiMessage: true); @@ -525,7 +536,7 @@ public static partial class AcBinarySerializer /// Flush strategy auto-selected by writer type — see /// . /// - public static int SerializeChunkedFramed(T value, System.IO.Pipelines.PipeWriter pipeWriter, AcBinarySerializerOptions options) + public static int SerializeChunkedFramed<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] T>(T value, System.IO.Pipelines.PipeWriter pipeWriter, AcBinarySerializerOptions options) => SerializeToPipeWriterCore(value, pipeWriter, options, FlushPolicy.DoubleBuffered, flushTimeout: null, multiMessage: true); /// @@ -1772,7 +1783,17 @@ public static partial class AcBinarySerializer /// UseMetadata=true: skip marker for defaults, type code + value for non-defaults. /// UseMetadata=false (markerless): raw value only, no skip markers. /// + /// + /// NativeAOT note: the polymorphism path uses value.GetType() to obtain the runtime type, + /// which inherently loses the DAMs annotation chain. Polymorphic concrete types must therefore + /// be rooted by the consumer (either via [AcBinarySerializable] + SGen, or + /// <TrimmerRootAssembly>). The IL2072 suppression below is bounded to this + /// well-known trimmer blind spot — runtime polymorphism is a fundamental limitation, not a bug. + /// [MethodImpl(MethodImplOptions.AggressiveInlining)] + [System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessage("Trimming", "IL2072", + Justification = "Polymorphism via obj.GetType() is a documented trimmer blind spot. Consumers must root " + + "polymorphic concrete types via [AcBinarySerializable] (SGen) or TrimmerRootAssembly.")] private static void WritePropertyOrSkip(object obj, BinaryPropertyAccessor prop, TypeMetadataWrapper parentWrapper, BinarySerializationContext context, int depth) where TOutput : struct, IBinaryOutputBase { diff --git a/AyCode.Core/Serializers/Binaries/BinaryPropertyAccessorBase.cs b/AyCode.Core/Serializers/Binaries/BinaryPropertyAccessorBase.cs index 71e029f..2ca1560 100644 --- a/AyCode.Core/Serializers/Binaries/BinaryPropertyAccessorBase.cs +++ b/AyCode.Core/Serializers/Binaries/BinaryPropertyAccessorBase.cs @@ -1,3 +1,4 @@ +using System.Diagnostics.CodeAnalysis; using System.Reflection; using System.Runtime.CompilerServices; using AyCode.Core.Serializers.Attributes; @@ -70,7 +71,10 @@ public abstract class BinaryPropertyAccessorBase : PropertyAccessorBase /// public byte? ExpectedTypeCode { get; } - protected BinaryPropertyAccessorBase(PropertyInfo prop, Type declaringType, bool enableInternString) + protected BinaryPropertyAccessorBase( + PropertyInfo prop, + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType, + bool enableInternString) : base(prop, declaringType) { IsStringCollectionProperty = IsStringCollection(prop.PropertyType); diff --git a/AyCode.Core/Serializers/Binaries/BinaryPropertySetterBase.cs b/AyCode.Core/Serializers/Binaries/BinaryPropertySetterBase.cs index c2dcb23..7bdd07c 100644 --- a/AyCode.Core/Serializers/Binaries/BinaryPropertySetterBase.cs +++ b/AyCode.Core/Serializers/Binaries/BinaryPropertySetterBase.cs @@ -1,4 +1,5 @@ using System.Collections; +using System.Diagnostics.CodeAnalysis; using System.Reflection; using System.Runtime.CompilerServices; using static AyCode.Core.Helpers.JsonUtilities; @@ -38,7 +39,9 @@ public abstract class BinaryPropertySetterBase : PropertySetterBase /// public byte? ExpectedTypeCode { get; } - protected BinaryPropertySetterBase(PropertyInfo prop, Type declaringType) + protected BinaryPropertySetterBase( + PropertyInfo prop, + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType) : base(prop, declaringType) { IsCollection = IsCollectionTypeCheck(PropertyType); @@ -120,6 +123,6 @@ public abstract class BinaryPropertySetterBase : PropertySetterBase PropertyAccessorType.UInt64 => BinaryTypeCode.UInt64, PropertyAccessorType.Boolean => BinaryTypeCode.True, PropertyAccessorType.Enum => BinaryTypeCode.Enum, - _ => null // String, Object always read marker from stream + _ => null // String, Object � always read marker from stream }; } diff --git a/AyCode.Core/Serializers/DeserializeTypeMetadataBase.cs b/AyCode.Core/Serializers/DeserializeTypeMetadataBase.cs index e1071c1..fc25233 100644 --- a/AyCode.Core/Serializers/DeserializeTypeMetadataBase.cs +++ b/AyCode.Core/Serializers/DeserializeTypeMetadataBase.cs @@ -1,3 +1,4 @@ +using System.Diagnostics.CodeAnalysis; using System.Reflection; namespace AyCode.Core.Serializers; @@ -10,7 +11,10 @@ namespace AyCode.Core.Serializers; /// public abstract class DeserializeTypeMetadataBase : TypeMetadataBase { - protected DeserializeTypeMetadataBase(Type type, Func ignorePropertyFilter) : base(type, ignorePropertyFilter) + protected DeserializeTypeMetadataBase( + [DynamicallyAccessedMembers(RequiredMembers)] Type type, + Func ignorePropertyFilter) + : base(type, ignorePropertyFilter) { // IId info is now initialized in TypeMetadataBase constructor } diff --git a/AyCode.Core/Serializers/Jsons/AcJsonDeserializer.JsonDeserializationContext.cs b/AyCode.Core/Serializers/Jsons/AcJsonDeserializer.JsonDeserializationContext.cs index 871cdfd..a28e763 100644 --- a/AyCode.Core/Serializers/Jsons/AcJsonDeserializer.JsonDeserializationContext.cs +++ b/AyCode.Core/Serializers/Jsons/AcJsonDeserializer.JsonDeserializationContext.cs @@ -66,8 +66,9 @@ public static partial class AcJsonDeserializer /// /// Factory for creating JsonDeserializeTypeMetadata instances. /// - protected override Func MetadataFactory - => static t => new JsonDeserializeTypeMetadata(t); + protected override MetadataFactoryDelegate MetadataFactory + => static ([System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] t) + => new JsonDeserializeTypeMetadata(t); public DeserializationContext(in AcJsonSerializerOptions options) { diff --git a/AyCode.Core/Serializers/Jsons/AcJsonDeserializer.JsonDeserializeTypeMetadata.cs b/AyCode.Core/Serializers/Jsons/AcJsonDeserializer.JsonDeserializeTypeMetadata.cs index b59965e..48d793f 100644 --- a/AyCode.Core/Serializers/Jsons/AcJsonDeserializer.JsonDeserializeTypeMetadata.cs +++ b/AyCode.Core/Serializers/Jsons/AcJsonDeserializer.JsonDeserializeTypeMetadata.cs @@ -2,6 +2,7 @@ using AyCode.Core.Helpers; using AyCode.Core.Serializers; using System.Collections.Concurrent; using System.Collections.Frozen; +using System.Diagnostics.CodeAnalysis; using System.Reflection; using System.Runtime.CompilerServices; using System.Text.Json; @@ -20,7 +21,9 @@ public static partial class AcJsonDeserializer public FrozenDictionary PropertySettersFrozen { get; } public PropertySetterInfo[] PropertiesArray { get; } // Array for fast UTF8 linear scan (small objects) - public JsonDeserializeTypeMetadata(Type type) : base(type, HasJsonIgnoreAttribute) + public JsonDeserializeTypeMetadata( + [DynamicallyAccessedMembers(RequiredMembers)] Type type) + : base(type, HasJsonIgnoreAttribute) { // Use pre-computed WritableProperties directly - no method call overhead! var props = WritableProperties; diff --git a/AyCode.Core/Serializers/Jsons/AcJsonSerializer.JsonSerializationContext.cs b/AyCode.Core/Serializers/Jsons/AcJsonSerializer.JsonSerializationContext.cs index 7185335..2793c07 100644 --- a/AyCode.Core/Serializers/Jsons/AcJsonSerializer.JsonSerializationContext.cs +++ b/AyCode.Core/Serializers/Jsons/AcJsonSerializer.JsonSerializationContext.cs @@ -71,8 +71,9 @@ public static partial class AcJsonSerializer /// /// Factory for creating JsonSerializeTypeMetadata instances. /// - protected override Func MetadataFactory - => static t => new JsonSerializeTypeMetadata(t); + protected override MetadataFactoryDelegate MetadataFactory + => static ([System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] t) + => new JsonSerializeTypeMetadata(t); public override void Reset(AcJsonSerializerOptions options) { diff --git a/AyCode.Core/Serializers/Jsons/AcJsonSerializer.JsonSerializeTypeMetadata.cs b/AyCode.Core/Serializers/Jsons/AcJsonSerializer.JsonSerializeTypeMetadata.cs index ddc0906..8d78245 100644 --- a/AyCode.Core/Serializers/Jsons/AcJsonSerializer.JsonSerializeTypeMetadata.cs +++ b/AyCode.Core/Serializers/Jsons/AcJsonSerializer.JsonSerializeTypeMetadata.cs @@ -1,4 +1,5 @@ using System.Collections.Concurrent; +using System.Diagnostics.CodeAnalysis; using System.Reflection; using System.Runtime.CompilerServices; using System.Text.Json; @@ -12,7 +13,9 @@ public static partial class AcJsonSerializer { public PropertyAccessor[] Properties { get; } - public JsonSerializeTypeMetadata(Type type) : base(type, JsonUtilities.HasJsonIgnoreAttribute) + public JsonSerializeTypeMetadata( + [DynamicallyAccessedMembers(RequiredMembers)] Type type) + : base(type, JsonUtilities.HasJsonIgnoreAttribute) { // Use pre-computed ReadableProperties directly - no method call overhead! Properties = ReadableProperties diff --git a/AyCode.Core/Serializers/PropertyAccessorBase.cs b/AyCode.Core/Serializers/PropertyAccessorBase.cs index 559d216..437e742 100644 --- a/AyCode.Core/Serializers/PropertyAccessorBase.cs +++ b/AyCode.Core/Serializers/PropertyAccessorBase.cs @@ -1,3 +1,4 @@ +using System.Diagnostics.CodeAnalysis; using System.Reflection; using System.Runtime.CompilerServices; using static AyCode.Core.Helpers.JsonUtilities; @@ -31,13 +32,17 @@ public abstract class PropertyAccessorBase : PropertyMetadataBase #endregion - protected PropertyAccessorBase(PropertyInfo prop, Type declaringType) + protected PropertyAccessorBase( + PropertyInfo prop, + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType) : base(prop, declaringType) { InitializeTypedGetter(declaringType, prop); } - private void InitializeTypedGetter(Type declaringType, PropertyInfo prop) + private void InitializeTypedGetter( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType, + PropertyInfo prop) { switch (AccessorType) { diff --git a/AyCode.Core/Serializers/PropertyMetadataBase.cs b/AyCode.Core/Serializers/PropertyMetadataBase.cs index 38ed38c..a95e624 100644 --- a/AyCode.Core/Serializers/PropertyMetadataBase.cs +++ b/AyCode.Core/Serializers/PropertyMetadataBase.cs @@ -1,3 +1,4 @@ +using System.Diagnostics.CodeAnalysis; using System.Reflection; using System.Runtime.CompilerServices; using System.Text; @@ -93,7 +94,9 @@ public abstract class PropertyMetadataBase /// protected readonly Func _dynamicGetter; - protected PropertyMetadataBase(PropertyInfo prop, Type declaringType) + protected PropertyMetadataBase( + PropertyInfo prop, + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType) { Name = prop.Name; NameUtf8 = Encoding.UTF8.GetBytes(prop.Name); diff --git a/AyCode.Core/Serializers/PropertySetterBase.cs b/AyCode.Core/Serializers/PropertySetterBase.cs index f81410a..2dc1b1d 100644 --- a/AyCode.Core/Serializers/PropertySetterBase.cs +++ b/AyCode.Core/Serializers/PropertySetterBase.cs @@ -1,4 +1,5 @@ using System.Collections; +using System.Diagnostics.CodeAnalysis; using System.Reflection; using System.Runtime.CompilerServices; using static AyCode.Core.Helpers.JsonUtilities; @@ -57,20 +58,29 @@ public abstract class PropertySetterBase : PropertyMetadataBase #endregion - protected PropertySetterBase(PropertyInfo prop, Type declaringType) + protected PropertySetterBase( + PropertyInfo prop, + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType) : base(prop, declaringType) { _setter = AcSerializerCommon.CreateCompiledSetter(declaringType, prop); - + // Initialize typed setter InitializeTypedSetter(declaringType, prop); - - // Determine collection element type + + // Determine collection element type. ElementType is derived from PropertyType via reflection + // (generic argument extraction) — the trimmer cannot statically prove the DAMs requirement on + // CreateCompiledGetter below. The element type's PublicProperties metadata is preserved + // transitively via the consumer's [DynamicallyAccessedMembers(PublicProperties)] on the root + // type T (Deserialize): when T is preserved with PublicProperties, the trimmer keeps each + // property's PropertyType reference, and for collection-typed properties the generic argument + // (T's element type) is reachable. The actual ctor + property metadata of element types must + // be rooted by the consumer or via [AcBinarySerializable] on the element types. ElementType = GetCollectionElementType(PropertyType); - - var isCollection = ElementType != null && - ElementType != typeof(object) && - typeof(IEnumerable).IsAssignableFrom(PropertyType) && + + var isCollection = ElementType != null && + ElementType != typeof(object) && + typeof(IEnumerable).IsAssignableFrom(PropertyType) && !ReferenceEquals(PropertyType, StringType); if (isCollection && ElementType != null) @@ -80,14 +90,33 @@ public abstract class PropertySetterBase : PropertyMetadataBase { IsIIdCollection = true; ElementIdType = idInfo.IdType; - var idProp = ElementType.GetProperty("Id"); - if (idProp != null) - ElementIdGetter = AcSerializerCommon.CreateCompiledGetter(ElementType, idProp); + ElementIdGetter = TryCreateElementIdGetter(ElementType); } } } - private void InitializeTypedSetter(Type declaringType, PropertyInfo prop) + /// + /// Wrapper that hides the ElementType DAMs requirement from the trimmer at this call site — + /// the element type's reflection metadata is preserved transitively via the root type's + /// PublicProperties annotation (see ctor comment). Suppression is intentional and bounded. + /// + [UnconditionalSuppressMessage("Trimming", "IL2072", + Justification = "ElementType is derived from a [DynamicallyAccessedMembers(PublicProperties)] root via " + + "GetCollectionElementType(PropertyType). When the consumer's root type T is properly " + + "annotated, the element type's properties survive trimming via the property-type chain.")] + [UnconditionalSuppressMessage("Trimming", "IL2075", + Justification = "Same as IL2072 — ElementType.GetProperty(\"Id\") relies on the root-type DAMs chain.")] + private static Func? TryCreateElementIdGetter(Type elementType) + { + var idProp = elementType.GetProperty("Id"); + return idProp != null + ? AcSerializerCommon.CreateCompiledGetter(elementType, idProp) + : null; + } + + private void InitializeTypedSetter( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type declaringType, + PropertyInfo prop) { switch (AccessorType) { diff --git a/AyCode.Core/Serializers/SerializeTypeMetadataBase.cs b/AyCode.Core/Serializers/SerializeTypeMetadataBase.cs index b40542a..1f088e7 100644 --- a/AyCode.Core/Serializers/SerializeTypeMetadataBase.cs +++ b/AyCode.Core/Serializers/SerializeTypeMetadataBase.cs @@ -1,3 +1,4 @@ +using System.Diagnostics.CodeAnalysis; using System.Reflection; namespace AyCode.Core.Serializers; @@ -9,7 +10,9 @@ namespace AyCode.Core.Serializers; /// public abstract class SerializeTypeMetadataBase : TypeMetadataBase { - protected SerializeTypeMetadataBase(Type type, Func ignorePropertyFilter) + protected SerializeTypeMetadataBase( + [DynamicallyAccessedMembers(RequiredMembers)] Type type, + Func ignorePropertyFilter) : base(type, ignorePropertyFilter) { // Base class handles: diff --git a/AyCode.Core/Serializers/Toons/AcToonSerializer.ToonSerializationContext.cs b/AyCode.Core/Serializers/Toons/AcToonSerializer.ToonSerializationContext.cs index 416b3ce..3502433 100644 --- a/AyCode.Core/Serializers/Toons/AcToonSerializer.ToonSerializationContext.cs +++ b/AyCode.Core/Serializers/Toons/AcToonSerializer.ToonSerializationContext.cs @@ -67,8 +67,9 @@ public static partial class AcToonSerializer /// /// Factory for creating ToonSerializeTypeMetadata instances. /// - protected override Func MetadataFactory - => static t => new ToonSerializeTypeMetadata(t); + protected override MetadataFactoryDelegate MetadataFactory + => static ([System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembers(TypeMetadataBase.RequiredMembers)] t) + => new ToonSerializeTypeMetadata(t); public override void Reset(AcToonSerializerOptions options) { diff --git a/AyCode.Core/Serializers/Toons/AcToonSerializer.ToonSerializeTypeMetadata.cs b/AyCode.Core/Serializers/Toons/AcToonSerializer.ToonSerializeTypeMetadata.cs index 6ddf81d..16b796f 100644 --- a/AyCode.Core/Serializers/Toons/AcToonSerializer.ToonSerializeTypeMetadata.cs +++ b/AyCode.Core/Serializers/Toons/AcToonSerializer.ToonSerializeTypeMetadata.cs @@ -1,4 +1,5 @@ using System.Collections; +using System.Diagnostics.CodeAnalysis; using System.Linq.Expressions; using System.Reflection; using System.Runtime.CompilerServices; @@ -22,7 +23,9 @@ public static partial class AcToonSerializer public Type? ElementType { get; } public ToonDescriptionAttribute? CustomDescription { get; } - public ToonSerializeTypeMetadata(Type type) : base(type, HasToonIgnoreAttribute) + public ToonSerializeTypeMetadata( + [DynamicallyAccessedMembers(RequiredMembers)] Type type) + : base(type, HasToonIgnoreAttribute) { TypeName = type.FullName ?? type.Name; ShortTypeName = type.Name; diff --git a/AyCode.Core/Serializers/TypeMetadataBase.cs b/AyCode.Core/Serializers/TypeMetadataBase.cs index b95eab6..703362e 100644 --- a/AyCode.Core/Serializers/TypeMetadataBase.cs +++ b/AyCode.Core/Serializers/TypeMetadataBase.cs @@ -5,6 +5,7 @@ using System; using System.Collections; using System.Collections.Concurrent; using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; @@ -188,7 +189,24 @@ public abstract class TypeMetadataBase [MethodImpl(MethodImplOptions.AggressiveInlining)] public Guid GetIdGuid(object obj) => ((Func)TypedIdGetter!)(obj); - protected TypeMetadataBase(Type type, Func ignorePropertyFilter) + /// + /// Combined DAMs requirement for any Type that flows into construction. + /// — required by the + /// CreateCompiledConstructor path (deserialize side) so Type.GetConstructor / + /// Activator.CreateInstance survive AOT trimming. + /// — required by + /// GetUnfilteredProperties and the typed/dynamic property-accessor factories so + /// Type.GetProperties / PropertyInfo.GetValue / SetValue survive AOT trimming. + /// Public so derived metadata classes (BinarySerializeTypeMetadata, JsonSerializeTypeMetadata, etc.) + /// can reference the same constant in their own DAMs annotations and stay in sync. + /// + public const DynamicallyAccessedMemberTypes RequiredMembers = + DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | + DynamicallyAccessedMemberTypes.PublicProperties; + + protected TypeMetadataBase( + [DynamicallyAccessedMembers(RequiredMembers)] Type type, + Func ignorePropertyFilter) { SourceType = type; _ignorePropertyFilter = ignorePropertyFilter; @@ -299,32 +317,61 @@ public abstract class TypeMetadataBase // Id properties are sorted alphabetically like all other properties public const string IdPropertyName = nameof(IId.Id); - private static List GetUnfilteredProperties(Type type, bool requiresWrite) + private static List GetUnfilteredProperties( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type type, + bool requiresWrite) { - return UnfilteredPropertiesGlobalCache.GetOrAdd((type, requiresWrite), static key => + // Cache lookup keyed by (Type, bool). The cache hit path returns without DAMs context — that's + // fine because the cached PropertyInfo[] was built when DAMs was honored. Cache miss path + // dispatches to BuildPropertyList which carries the DAMs annotation through the call chain. + if (UnfilteredPropertiesGlobalCache.TryGetValue((type, requiresWrite), out var cached)) + return cached; + + var built = BuildPropertyList(type, requiresWrite); + UnfilteredPropertiesGlobalCache.TryAdd((type, requiresWrite), built); + return built; + } + + /// + /// Walks the inheritance chain to collect declared public instance properties. + /// + /// + /// The BaseType walk is a documented trimmer blind spot — DAMs annotations cannot follow + /// . The IL2070/IL2080 suppression below is bounded: when consumers + /// preserve their root type T via DAMs, the runtime trimmer keeps T's full inheritance chain + /// (a base type of a kept type is itself kept), so GetProperties on each level finds + /// preserved metadata. The blind spot is in static analysis only; runtime correctness is sound + /// for any type rooted via Deserialize<T>'s DAMs requirement. + /// + [UnconditionalSuppressMessage("Trimming", "IL2070", + Justification = "BaseType walk: trimmer cannot follow DAMs through Type.BaseType. Consumer-side " + + "DAMs on Deserialize's T preserves the full inheritance chain at runtime.")] + [UnconditionalSuppressMessage("Trimming", "IL2080", + Justification = "Same as IL2070 — currentType variable starts DAMs-annotated but loses annotation " + + "through the BaseType reassignment in the loop.")] + private static List BuildPropertyList( + [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type type, + bool requiresWrite) + { + // Collect properties from inheritance hierarchy (derived -> base order) + // Sorted alphabetically for deterministic property index ordering + var allProperties = new List(); + + for (var currentType = type; currentType != null && currentType != typeof(object); currentType = currentType.BaseType) { - var (t, needsWrite) = key; + // Get properties declared at this level only + var levelProperties = currentType + .GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) + .Where(p => p.CanRead && + (!requiresWrite || p.CanWrite) && + p.GetIndexParameters().Length == 0 && + !IsUnsupportedPropertyType(p.PropertyType)) + .OrderBy(static p => p.Name, StringComparer.Ordinal); - // Collect properties from inheritance hierarchy (derived -> base order) - // Sorted alphabetically for deterministic property index ordering - var allProperties = new List(); + allProperties.AddRange(levelProperties); + } - for (var currentType = t; currentType != null && currentType != typeof(object); currentType = currentType.BaseType) - { - // Get properties declared at this level only - var levelProperties = currentType - .GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly) - .Where(p => p.CanRead && - (!needsWrite || p.CanWrite) && - p.GetIndexParameters().Length == 0 && - !IsUnsupportedPropertyType(p.PropertyType)) - .OrderBy(static p => p.Name, StringComparer.Ordinal); - - allProperties.AddRange(levelProperties); - } - - return allProperties; - }); + return allProperties; } [MethodImpl(MethodImplOptions.AggressiveInlining)] diff --git a/AyCode.Core/docs/BINARY/BINARY_FEATURES.md b/AyCode.Core/docs/BINARY/BINARY_FEATURES.md index 13af74a..8ffaf59 100644 --- a/AyCode.Core/docs/BINARY/BINARY_FEATURES.md +++ b/AyCode.Core/docs/BINARY/BINARY_FEATURES.md @@ -79,6 +79,41 @@ SGen root types use a **fast path** that skips the full dispatch chain (~12 call > Full SGen architecture, bridge methods, generated code patterns, wrapper slots: `BINARY_SGEN.md` +## NativeAOT Compatibility + +Both execution modes work under NativeAOT publish. SGen is the recommended path; Runtime works but is significantly slower. + +| Path | AOT compatible? | Performance vs JIT | Recommendation | +|------|-----------------|--------------------|----| +| **SGen** (`[AcBinarySerializable]` + `UseGeneratedCode=true`) | ✅ Full | Same as JIT | Production AOT default | +| **Runtime** (no attribute or `UseGeneratedCode=false`) | ✅ Functional | ~5-7x slower than SGen | Fallback for unattributed types | + +### Two-axis AOT strategy + +NativeAOT has two distinct constraints — both must be addressed for the Runtime path to work: + +1. **Dynamic code generation prohibited.** `Expression.Compile()` and `Reflection.Emit` fail under AOT (no JIT engine in the binary). The 7 property-accessor + constructor factories in `AcSerializerCommon` use `if (!RuntimeFeature.IsDynamicCodeSupported)` runtime guards to fall back to plain reflection delegates (`PropertyInfo.GetValue/SetValue`, `ConstructorInfo.Invoke`). + +2. **Reflection metadata trim.** The trimmer drops `Type.GetConstructor()` / `Type.GetProperties()` metadata for types not statically referenced. The library propagates `[DynamicallyAccessedMembers(PublicParameterlessConstructor | PublicProperties)]` from the public `Deserialize` / `Serialize` entry points down through the metadata classes. The `RequiredMembers` constant on `TypeMetadataBase` is the single source of truth for the DAMs requirement. + +### Documented trimmer blind spots + +Two well-known limitations require consumer cooperation: + +- **Polymorphism via `obj.GetType()`** — `WritePropertyOrSkip` writes the runtime concrete type for polymorphic properties; the trimmer cannot follow `GetType()` flow. Consumer must root polymorphic concrete types: either via `[AcBinarySerializable]` on each (SGen path covers them) or `` for the data-model assembly. The IL2072 warning is suppressed at this site with documented justification. +- **Nested types via property-type chain** — `List` element type extracted via `Type.GetGenericArguments()` loses DAMs context. Same mitigation: `[AcBinarySerializable]` on each nested type, or ``. The IL2072/IL2075 warnings are suppressed at the relevant sites with documented justification. + +### Consumer guidance for AOT publish + +- Annotate every type in the serialization graph with `[AcBinarySerializable]` — SGen path is AOT-clean and ~5-7x faster than the Runtime fallback. +- Or, for unattributed types: add `` in the consumer's csproj to keep reflection metadata for the data-model assembly intact (cost: larger AOT binary). +- The `MessagePackSerializer.Standard` resolver has the same `Reflection.Emit` problem — use MessagePack source generators or skip MessagePack under AOT (the AcBinary benchmark project does the latter via `#if !AYCODE_NATIVEAOT`). +- `System.Text.Json` reflection mode similarly requires `JsonSerializerIsReflectionEnabledByDefault=true` AND consumer awareness; for AOT the source-gen path is preferred. + +### Verified + +The full benchmark suite (Small/Medium/Large/Repeated Strings/Deep Nested) runs cleanly under NativeAOT publish on Windows x64 + .NET 9. AcBinary SGen retains its **+12-35% speed and -22-33% wire-size advantage over MemoryPack** under AOT, identical to JIT. Runtime path is functional but ~5-7x slower (reflection-delegate overhead). + ## Property Ordering Properties are serialized in a deterministic order defined by `TypeMetadataBase.GetUnfilteredProperties()`: diff --git a/AyCode.Core/docs/BINARY/BINARY_TODO.md b/AyCode.Core/docs/BINARY/BINARY_TODO.md index cbc5f65..dc89c71 100644 --- a/AyCode.Core/docs/BINARY/BINARY_TODO.md +++ b/AyCode.Core/docs/BINARY/BINARY_TODO.md @@ -583,3 +583,78 @@ FNV-1a is currently used for both `s_typeNameHash` and `s_propertyHashes`. For c Investigation only — defer until pain signal arrives. +## ACCORE-BIN-T-K9E4: `[RequiresDynamicCode]` + `[RequiresUnreferencedCode]` on Runtime-only methods +**Priority:** P3 · **Type:** Refactor · **Related:** `BINARY_FEATURES.md#nativeaot-compatibility` + +The Runtime path (factories in `AcSerializerCommon` + wrapper-based deserialize fallback in `AcBinaryDeserializer`) currently works under NativeAOT thanks to DAMs propagation + `RuntimeFeature.IsDynamicCodeSupported` guards, but the trimmer still emits warnings for the well-known blind spots (polymorphism via `obj.GetType()`, nested-type chain via generic argument extraction). The library suppresses these with `[UnconditionalSuppressMessage]` and documented justification. + +A complementary signal would be to mark the Runtime entry points (or the factories themselves) with `[RequiresDynamicCode("AcBinary Runtime path uses Reflection.Emit / closed-generic instantiation; use [AcBinarySerializable] + SGen for NativeAOT.")]` and `[RequiresUnreferencedCode("...")]`. Effect: + +- AOT publish in consumer's project surfaces a warning at the call site → consumer chooses SGen or accepts the Runtime cost +- Mirrors the System.Text.Json reflection-mode pattern (`[RequiresDynamicCode]` on `JsonSerializer.Serialize` overloads) +- One-codebase, no NuGet split needed +- Cheap implementation — attribute placement only + +**Coordination:** `[RequiresDynamicCode]` is contagious; every caller must either propagate it or suppress with `[UnconditionalSuppressMessage]`. Scope: +- Public `Serialize` / `Deserialize` entry points stay attribute-free (consumer-facing) +- Runtime fallback methods get the attribute (contained inside the library) +- The DAMs annotations we already have stay — they're orthogonal (one prevents trim, the other warns about JIT-only behavior) + +**Acceptance:** +- Consumer's AOT publish surfaces a IL2026/IL3050 warning when `UseGeneratedCode=false` is set or an unattributed type is deserialized +- SGen path is warning-free +- Library compiles 0 warnings (suppressions added at the propagation barrier) +- `BINARY_FEATURES.md` NativeAOT Compatibility section updated to mention the explicit warning signal + +## ACCORE-BIN-T-A2J7: Optional `AyCode.Core.Aot` NuGet variant (SGen-only build) +**Priority:** P3 · **Type:** Feature · **Related:** `BINARY_FEATURES.md#nativeaot-compatibility`, `ACCORE-BIN-T-K9E4` + +Binary-size-sensitive AOT consumers (Blazor WASM, MAUI mobile, embedded, container-trimmed) benefit from a smaller library variant that strips the Runtime fallback path entirely. Estimated savings: ~80-150 KB of native code (~25-60 KB compressed wire size for WASM publish). + +**Strippable code in the `.Aot` variant:** + +| Component | LOC | Purpose | Removable in Aot? | +|---|---|---|---| +| `AcSerializerCommon.Create*` (7 factory methods + Expression-tree code) | ~150 | Runtime delegate compilation | ✅ Yes | +| `TypeMetadataBase` runtime metadata path (`CompiledConstructor`, IdGetters via Expression.Compile) | ~300 | Reflection-based metadata | ✅ Yes | +| `AcBinaryDeserializer` wrapper-based runtime fallback (`PopulateObjectPropertiesIndexed`, `ReadObjectCoreWithWrapper` non-SGen branches, `CreateInstance(type)` Activator-fallback) | ~500 | Runtime polymorphic dispatch | ✅ Yes | +| Property accessor runtime delegate fields (`_dynamicGetter`, typed getter/setter caches outside SGen) | ~150 | Boxed property access | ✅ Yes | +| `System.Linq.Expressions` transitive dependency | — | Expression-tree IL emission | ✅ Yes (when nothing else in graph uses it) | + +**Implementation sketch** (avoid `#if`-erdő via file-level split): + +``` +AyCode.Core/Serializers/ + AcSerializerCommon.cs // SGen-safe shared parts + AcSerializerCommon.Runtime.cs // 7 Create* factory methods only here + AcBinaryDeserializer.cs // SGen path + AcBinaryDeserializer.Runtime.cs // wrapper-based runtime fallback path + TypeMetadataBase.cs // SGen-safe metadata + TypeMetadataBase.Runtime.cs // Expression.Compile-based ctor + accessor wiring +``` + +Two `.csproj` files: +- `AyCode.Core.csproj` — full package (current); includes all files +- `AyCode.Core.Aot.csproj` — ``; sets `AyCode.Core.Aot`; same version as full + +**Trade-offs:** + +- ✅ No `#if` directives in business code — physically separate file groups +- ✅ Source mostly shared via SDK include/exclude semantics +- ✅ DAMs annotations and trim-suppressions only land in the full package; `.Aot` variant is genuinely trim-clean by construction +- ✅ "Strict SGen" semantics in `.Aot`: a non-SGen type at deser time throws clearly instead of silently falling back. Marketing positioning: "guaranteed SGen path, no hidden slow lane". +- ⚠️ Two NuGet IDs, two changelogs, version sync (CI-automatable) +- ⚠️ Consumer must pick the right package — wrong choice = breaking switch later + +**Coordination:** +- Land `ACCORE-BIN-T-K9E4` first (`[RequiresDynamicCode]` attributes) — if that pattern handles the consumer-side scenarios well, `.Aot` may not be needed +- The current Runtime fallback code is already well-isolated (mostly in `AcSerializerCommon` factories + `AcBinaryDeserializer` wrapper-based methods), so the file-split refactor is mechanically straightforward +- Marketing decision: is binary size a central pillar? If yes, `.Aot` is a NuGet differentiator; if not, `K9E4` alone is enough + +**Acceptance:** +- `AyCode.Core.Aot.csproj` produces a NuGet ~25-60 KB smaller than `AyCode.Core` after compression +- `.Aot` build emits zero IL/AOT trim warnings (no suppressions needed because the Runtime path code is physically removed) +- Round-trip tests pass on `.Aot` for all SGen types +- `.Aot` throws a clear `InvalidOperationException` (not `MissingMethodException`) when a non-`[AcBinarySerializable]` type is encountered at deser time +- `BINARY_FEATURES.md` NativeAOT Compatibility section documents both packages and when to choose which +