1691 lines
67 KiB
C#
1691 lines
67 KiB
C#
using AyCode.Core.Compression;
|
|
using AyCode.Core.Helpers;
|
|
using AyCode.Core.Serializers.Expressions;
|
|
using System.Buffers;
|
|
using System.Collections;
|
|
using System.Collections.Concurrent;
|
|
using System.Linq.Expressions;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
using AyCode.Core.Serializers.Jsons;
|
|
using static AyCode.Core.Helpers.JsonUtilities;
|
|
|
|
namespace AyCode.Core.Serializers.Binaries;
|
|
|
|
/// <summary>
|
|
/// High-performance binary serializer optimized for speed and memory efficiency.
|
|
/// Features:
|
|
/// - VarInt encoding for compact integers (MessagePack-style)
|
|
/// - String interning for repeated strings
|
|
/// - Property name table for fast lookup
|
|
/// - Reference handling for circular/shared references
|
|
/// - Optional metadata for schema evolution
|
|
/// - Optimized buffer management with ArrayPool
|
|
/// - Zero-allocation hot paths using Span and MemoryMarshal
|
|
/// - Automatic Expression to AcExpressionNode conversion
|
|
/// - Generic TOutput for output strategy selection (ArrayBinaryOutput / BufferWriterBinaryOutput)
|
|
/// - Buffer-in-context: _buffer/_position owned by context for zero virtual dispatch on hot path
|
|
/// </summary>
|
|
public static partial class AcBinarySerializer
|
|
{
|
|
|
|
// Pre-computed UTF8 encoder for string operations
|
|
private static readonly Encoding Utf8NoBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);
|
|
private static readonly Type StringType = typeof(string);
|
|
private static readonly Type GuidType = typeof(Guid);
|
|
private static readonly Type DateTimeOffsetType = typeof(DateTimeOffset);
|
|
private static readonly Type TimeSpanType = typeof(TimeSpan);
|
|
private static readonly Type IntType = typeof(int);
|
|
private static readonly Type LongType = typeof(long);
|
|
private static readonly Type FloatType = typeof(float);
|
|
private static readonly Type DoubleType = typeof(double);
|
|
private static readonly Type DecimalType = typeof(decimal);
|
|
private static readonly Type BoolType = typeof(bool);
|
|
private static readonly Type DateTimeType = typeof(DateTime);
|
|
|
|
#region Public API
|
|
|
|
#if DEBUG
|
|
/// <summary>
|
|
/// DEBUG ONLY: Analyzes which string properties have repeated values that would benefit from interning.
|
|
/// Returns a dictionary where key is "TypeName.PropertyName" and value is the occurrence count.
|
|
/// Only properties with count > 1 are good candidates for [StringIntern] attribute.
|
|
/// </summary>
|
|
/// <param name="value">The object graph to analyze.</param>
|
|
/// <param name="options">Serializer options (UseStringInterning should be enabled).</param>
|
|
/// <returns>Dictionary of property paths to their string occurrence counts.</returns>
|
|
public static Dictionary<string, Dictionary<string, int>> AnalyzeStringInternCandidates<T>(T value, AcBinarySerializerOptions? options = null)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(value);
|
|
|
|
options ??= AcBinarySerializerOptions.Default;
|
|
|
|
// For analysis, use the provided reference handling mode
|
|
var analysisOptions = new AcBinarySerializerOptions
|
|
{
|
|
UseStringInterning = StringInterningMode.All,
|
|
MinStringInternLength = options.MinStringInternLength,
|
|
MaxStringInternLength = options.MaxStringInternLength,
|
|
ReferenceHandling = options.ReferenceHandling
|
|
};
|
|
|
|
var result = new Dictionary<string, Dictionary<string, int>>();
|
|
var runtimeType = value.GetType();
|
|
|
|
// Create context without pooling (we need to set up callback)
|
|
using var context = new BinarySerializationContext<ArrayBinaryOutput>(analysisOptions);
|
|
context.Output = new ArrayBinaryOutput(4096);
|
|
context.OutputInitialized = true;
|
|
context.Output.Initialize(out context._buffer, out context._position, out context._bufferEnd);
|
|
|
|
// Set up tracking callbacks
|
|
context.OnStringInterned = (propertyPath, stringValue) =>
|
|
{
|
|
propertyPath ??= "(unknown)";
|
|
|
|
if (!result.TryGetValue(stringValue, out var properties))
|
|
{
|
|
properties = new Dictionary<string, int>();
|
|
result[stringValue] = properties;
|
|
}
|
|
|
|
properties[propertyPath] = properties.GetValueOrDefault(propertyPath) + 1;
|
|
};
|
|
|
|
// Run serialization to trigger callbacks
|
|
context.WriteHeader();
|
|
WriteValue(value, runtimeType, context, 0);
|
|
|
|
return result;
|
|
}
|
|
|
|
public static StringBuilder GetAnalyzeStringInternCandidatesLog<T>(T value, AcBinarySerializerOptions? options = null)
|
|
{
|
|
var sb = new StringBuilder();
|
|
options ??= AcBinarySerializerOptions.Default;
|
|
var analysis = AnalyzeStringInternCandidates(value, options);
|
|
|
|
// Transform: stringValue → properties TO propertyPath → (stringValue, count)
|
|
var propertyStats = new Dictionary<string, List<(string StringValue, int Count, int ByteLength)>>();
|
|
|
|
foreach (var (stringValue, properties) in analysis)
|
|
{
|
|
var byteLength = Encoding.UTF8.GetByteCount(stringValue);
|
|
foreach (var (propPath, count) in properties)
|
|
{
|
|
if (!propertyStats.TryGetValue(propPath, out var list))
|
|
{
|
|
list = [];
|
|
propertyStats[propPath] = list;
|
|
}
|
|
list.Add((stringValue, count, byteLength));
|
|
}
|
|
}
|
|
|
|
var refMode = options.ReferenceHandling;
|
|
|
|
// Header
|
|
sb.AppendLine("+==============================================================================+");
|
|
sb.AppendLine($"| STRING INTERN ANALYSIS REPORT (RefMode: {refMode,-12}) |");
|
|
sb.AppendLine("+==============================================================================+");
|
|
sb.AppendLine();
|
|
|
|
// Global summary
|
|
var totalStrings = analysis.Values.Sum(p => p.Values.Sum());
|
|
var uniqueStrings = analysis.Count;
|
|
var repeatedStrings = analysis.Count(kv => kv.Value.Values.Sum() > 1);
|
|
|
|
sb.AppendLine("+-----------------------------------------------------------------------------+");
|
|
sb.AppendLine("| STRING SUMMARY |");
|
|
sb.AppendLine("+-----------------------------------------------------------------------------+");
|
|
sb.AppendLine($"| Total string occurrences: {totalStrings,-10} Unique strings: {uniqueStrings,-10} Repeated: {repeatedStrings,-8} |");
|
|
sb.AppendLine("+-----------------------------------------------------------------------------+");
|
|
sb.AppendLine();
|
|
|
|
// Property-focused table
|
|
// Calculate stats for each property first (for sorting by RepeatSum%)
|
|
var propertyStatsCalculated = propertyStats.Select(kv =>
|
|
{
|
|
var propPath = kv.Key;
|
|
var strings = kv.Value;
|
|
var total = strings.Sum(s => s.Count);
|
|
var unique = strings.Count;
|
|
var repeated = strings.Count(s => s.Count > 1);
|
|
var repeatSum = strings.Where(s => s.Count > 1).Sum(s => s.Count); // Sum of occurrences of repeated strings
|
|
var repeatSumPct = total > 0 ? repeatSum * 100.0 / total : 0;
|
|
|
|
// Calculate savings
|
|
var totalBytes = strings.Sum(s => s.Count * s.ByteLength);
|
|
var uniqueBytes = strings.Sum(s => s.ByteLength);
|
|
var indexBytes = total * 2;
|
|
var savings = totalBytes - (uniqueBytes + indexBytes);
|
|
|
|
return (propPath, strings, total, unique, repeated, repeatSum, repeatSumPct, savings);
|
|
}).ToList();
|
|
|
|
sb.AppendLine("+--------------------------------+-------+---------+--------+---------+-----------+----------+-------------+");
|
|
sb.AppendLine("| Property | Total | RepSum | Unique | Repeated| RepSum % | Savings | Recommend |");
|
|
sb.AppendLine("+--------------------------------+-------+---------+--------+---------+-----------+----------+-------------+");
|
|
|
|
foreach (var stat in propertyStatsCalculated.OrderByDescending(x => x.repeatSumPct))
|
|
{
|
|
var savingsStr = stat.savings > 0 ? $"+{stat.savings:N0}B" : $"{stat.savings:N0}B";
|
|
var recommend = stat.savings > 100 ? "[INTERN]" : stat.savings > 0 ? " maybe " : " skip ";
|
|
|
|
var propDisplay = stat.propPath.Length > 30 ? stat.propPath[..27] + "..." : stat.propPath;
|
|
sb.AppendLine($"| {propDisplay,-30} | {stat.total,5} | {stat.repeatSum,7} | {stat.unique,6} | {stat.repeated,7} | {stat.repeatSumPct,8:F1}% | {savingsStr,8} | {recommend,-11} |");
|
|
}
|
|
|
|
sb.AppendLine("+--------------------------------+-------+---------+--------+---------+-----------+----------+-------------+");
|
|
sb.AppendLine();
|
|
|
|
// Detailed property breakdown (only for properties with significant savings)
|
|
sb.AppendLine("+-----------------------------------------------------------------------------+");
|
|
sb.AppendLine("| DETAILED BREAKDOWN (properties with savings > 100 bytes) |");
|
|
sb.AppendLine("+-----------------------------------------------------------------------------+");
|
|
|
|
foreach (var stat in propertyStatsCalculated
|
|
.Where(x => x.savings > 100)
|
|
.OrderByDescending(x => x.repeatSumPct))
|
|
{
|
|
sb.AppendLine();
|
|
sb.AppendLine($" {stat.propPath} (RepSum: {stat.repeatSum}/{stat.total} = {stat.repeatSumPct:F1}%):");
|
|
|
|
foreach (var (strVal, count, _) in stat.strings.OrderByDescending(s => s.Count).Take(10))
|
|
{
|
|
var preview = strVal.Length > 40 ? strVal[..37] + "..." : strVal;
|
|
var marker = count > 1 ? ">" : " ";
|
|
sb.AppendLine($" {marker} [{count,4}x] \"{preview}\"");
|
|
}
|
|
|
|
if (stat.strings.Count > 10)
|
|
{
|
|
sb.AppendLine($" ... and {stat.strings.Count - 10} more unique values");
|
|
}
|
|
}
|
|
|
|
sb.AppendLine();
|
|
sb.AppendLine("===============================================================================");
|
|
sb.AppendLine("Legend: Total=all occurrences, RepSum=sum of repeated string occurrences");
|
|
sb.AppendLine(" Unique=distinct values, Repeated=count of values appearing 2+ times");
|
|
sb.AppendLine(" RepSum%=percentage of occurrences that are repeated (higher=better for intern)");
|
|
sb.AppendLine(" Savings=estimated bytes saved with interning (positive=good)");
|
|
sb.AppendLine(" > = repeated string (benefits from interning)");
|
|
|
|
return sb;
|
|
}
|
|
#endif
|
|
|
|
/// <summary>
|
|
/// Serialize object to binary with default options.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static byte[] Serialize<T>(T value) => Serialize(value, AcBinarySerializerOptions.Default);
|
|
|
|
/// <summary>
|
|
/// Serialize object to an IBufferWriter with default options.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
public static void Serialize<T>(T value, IBufferWriter<byte> writer) => Serialize(value, writer, AcBinarySerializerOptions.Default);
|
|
|
|
/// <summary>
|
|
/// Serialize object to binary with specified options.
|
|
/// Uses ArrayBinaryOutput for byte[] result path.
|
|
/// </summary>
|
|
public static byte[] Serialize<T>(T value, AcBinarySerializerOptions options)
|
|
{
|
|
if (value == null)
|
|
{
|
|
return [BinaryTypeCode.Null];
|
|
}
|
|
|
|
var runtimeType = value.GetType();
|
|
|
|
// Handle IQueryable types - convert to AcExpressionNode (serialize the Expression)
|
|
object actualValue = value;
|
|
if (value is IQueryable queryable)
|
|
{
|
|
actualValue = AcSerializerCommon.QueryableToNode(queryable);
|
|
runtimeType = typeof(AcExpressionNode);
|
|
}
|
|
// Handle Expression types - convert to AcExpressionNode
|
|
else if (AcSerializerCommon.IsExpressionType(runtimeType))
|
|
{
|
|
actualValue = AcExpressionConverter.ToNode((Expression)(object)value);
|
|
runtimeType = typeof(AcExpressionNode);
|
|
}
|
|
|
|
var context = BinarySerializationContextPool<ArrayBinaryOutput>.Get(options);
|
|
if (!context.OutputInitialized)
|
|
{
|
|
context.Output = new ArrayBinaryOutput(options.InitialBufferCapacity);
|
|
context.OutputInitialized = true;
|
|
}
|
|
context.Output.Initialize(out context._buffer, out context._position, out context._bufferEnd);
|
|
|
|
try
|
|
{
|
|
ScanForDuplicates(actualValue, runtimeType, context);
|
|
context.WriteHeader();
|
|
WriteValue(actualValue, runtimeType, context, 0);
|
|
|
|
// Apply compression if enabled - compress directly from buffer span (1 allocation)
|
|
if (options.UseCompression != Lz4CompressionMode.None)
|
|
{
|
|
return Lz4.Compress(context.Output.AsSpan(context._buffer, context._position), options.UseCompression);
|
|
}
|
|
|
|
// No compression - single allocation for result
|
|
return context.Output.ToArray(context._buffer, context._position);
|
|
}
|
|
finally
|
|
{
|
|
if (options.UseAsync) BinarySerializationContextPool<ArrayBinaryOutput>.ReturnAsync(context);
|
|
else BinarySerializationContextPool<ArrayBinaryOutput>.Return(context);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serialize object to an IBufferWriter for zero-copy scenarios.
|
|
/// Uses BufferWriterBinaryOutput — writes directly to the caller's buffer.
|
|
/// Note: Compression is applied if enabled in options.
|
|
/// </summary>
|
|
public static void Serialize<T>(T value, IBufferWriter<byte> writer, AcBinarySerializerOptions options)
|
|
{
|
|
if (value == null)
|
|
{
|
|
var span = writer.GetSpan(1);
|
|
span[0] = BinaryTypeCode.Null;
|
|
writer.Advance(1);
|
|
return;
|
|
}
|
|
|
|
var runtimeType = value.GetType();
|
|
|
|
// Handle IQueryable types - convert to AcExpressionNode (serialize the Expression)
|
|
object actualValue = value;
|
|
if (value is IQueryable queryable)
|
|
{
|
|
actualValue = AcSerializerCommon.QueryableToNode(queryable);
|
|
runtimeType = typeof(AcExpressionNode);
|
|
}
|
|
// Handle Expression types - convert to AcExpressionNode
|
|
else if (AcSerializerCommon.IsExpressionType(runtimeType))
|
|
{
|
|
actualValue = AcExpressionConverter.ToNode((Expression)(object)value);
|
|
runtimeType = typeof(AcExpressionNode);
|
|
}
|
|
|
|
var context = BinarySerializationContextPool<BufferWriterBinaryOutput>.Get(options);
|
|
context.Output = new BufferWriterBinaryOutput(writer);
|
|
context.Output.Initialize(out context._buffer, out context._position, out context._bufferEnd);
|
|
|
|
try
|
|
{
|
|
ScanForDuplicates(actualValue, runtimeType, context);
|
|
context.WriteHeader();
|
|
WriteValue(actualValue, runtimeType, context, 0);
|
|
|
|
// Apply compression if enabled
|
|
if (options.UseCompression != Lz4CompressionMode.None)
|
|
{
|
|
// For compression with BufferWriter, we need to flush first then compress
|
|
// This path is less common — compression typically uses byte[] path
|
|
context.Output.Flush(context._buffer, context._position);
|
|
// Compression with IBufferWriter requires intermediate buffer
|
|
// Fall back to ArrayBinaryOutput path for compression
|
|
throw new NotSupportedException(
|
|
"Compression is not supported with IBufferWriter output. " +
|
|
"Use the byte[] overload or disable compression.");
|
|
}
|
|
|
|
context.Output.Flush(context._buffer, context._position);
|
|
}
|
|
finally
|
|
{
|
|
context.Output = default;
|
|
if (options.UseAsync) BinarySerializationContextPool<BufferWriterBinaryOutput>.ReturnAsync(context);
|
|
else BinarySerializationContextPool<BufferWriterBinaryOutput>.Return(context);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the serialized size without allocating the final array.
|
|
/// Useful for pre-allocating buffers.
|
|
/// </summary>
|
|
public static int GetSerializedSize<T>(T value, AcBinarySerializerOptions options)
|
|
{
|
|
if (value == null) return 1;
|
|
|
|
var runtimeType = value.GetType();
|
|
|
|
var context = BinarySerializationContextPool<ArrayBinaryOutput>.Get(options);
|
|
if (!context.OutputInitialized)
|
|
{
|
|
context.Output = new ArrayBinaryOutput(options.InitialBufferCapacity);
|
|
context.OutputInitialized = true;
|
|
}
|
|
context.Output.Initialize(out context._buffer, out context._position, out context._bufferEnd);
|
|
|
|
try
|
|
{
|
|
ScanForDuplicates(value, runtimeType, context);
|
|
context.WriteHeader();
|
|
WriteValue(value, runtimeType, context, 0);
|
|
return context.Position;
|
|
}
|
|
finally
|
|
{
|
|
if (options.UseAsync) BinarySerializationContextPool<ArrayBinaryOutput>.ReturnAsync(context);
|
|
else BinarySerializationContextPool<ArrayBinaryOutput>.Return(context);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Serialize object and keep the pooled buffer for zero-copy consumers.
|
|
/// Caller must dispose the returned result to release the buffer.
|
|
/// Note: Compression is applied if enabled in options, result will be immutable (not pooled).
|
|
/// </summary>
|
|
public static BinarySerializationResult SerializeToPooledBuffer<T>(T value, AcBinarySerializerOptions options)
|
|
{
|
|
if (value == null)
|
|
{
|
|
return BinarySerializationResult.FromImmutable([BinaryTypeCode.Null]);
|
|
}
|
|
|
|
var runtimeType = value.GetType();
|
|
|
|
var context = BinarySerializationContextPool<ArrayBinaryOutput>.Get(options);
|
|
if (!context.OutputInitialized)
|
|
{
|
|
context.Output = new ArrayBinaryOutput(options.InitialBufferCapacity);
|
|
context.OutputInitialized = true;
|
|
}
|
|
context.Output.Initialize(out context._buffer, out context._position, out context._bufferEnd);
|
|
|
|
try
|
|
{
|
|
ScanForDuplicates(value, runtimeType, context);
|
|
context.WriteHeader();
|
|
WriteValue(value, runtimeType, context, 0);
|
|
|
|
// If compression enabled, compress directly from buffer span (1 allocation)
|
|
if (options.UseCompression != Lz4CompressionMode.None)
|
|
{
|
|
var compressed = Lz4.Compress(context.Output.AsSpan(context._buffer, context._position), options.UseCompression);
|
|
return BinarySerializationResult.FromImmutable(compressed);
|
|
}
|
|
|
|
return context.Output.DetachResult(context._buffer, context._position);
|
|
}
|
|
finally
|
|
{
|
|
if (options.UseAsync) BinarySerializationContextPool<ArrayBinaryOutput>.ReturnAsync(context);
|
|
else BinarySerializationContextPool<ArrayBinaryOutput>.Return(context);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Value Writing
|
|
|
|
private static void WriteValue<TOutput>(object? value, Type type, BinarySerializationContext<TOutput> context, int depth)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
if (value == null)
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Null);
|
|
return;
|
|
}
|
|
|
|
// Try writing as primitive first
|
|
if (TryWritePrimitive(value, type, context))
|
|
return;
|
|
|
|
WriteValueNonPrimitive(value, type, context, depth);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes a non-primitive value (collection, dictionary, byte[], or complex object).
|
|
/// Skips null check and TryWritePrimitive — caller guarantees value is non-null and not a primitive type.
|
|
/// Called from WritePropertyOrSkip default case (PropertyAccessorType.Object) and WriteValue fallback.
|
|
/// </summary>
|
|
private static void WriteValueNonPrimitive<TOutput>(object value, Type type, BinarySerializationContext<TOutput> context, int depth)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
// Nullable<T> where T is a value type: boxed value may be a primitive.
|
|
// Only Nullable<T> can be a value type in the Object accessor path.
|
|
if (type.IsValueType)
|
|
{
|
|
if (TryWritePrimitive(value, value.GetType(), context))
|
|
return;
|
|
}
|
|
|
|
if (depth > context.MaxDepth)
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Null);
|
|
return;
|
|
}
|
|
|
|
// Handle byte arrays specially (value-like, no reference tracking)
|
|
if (value is byte[] byteArray)
|
|
{
|
|
WriteByteArray(byteArray, context);
|
|
return;
|
|
}
|
|
|
|
// Handle dictionaries
|
|
if (value is IDictionary dictionary)
|
|
{
|
|
WriteDictionary(dictionary, context, depth);
|
|
return;
|
|
}
|
|
|
|
// Get wrapper once — used by both WriteArray and WriteObject
|
|
var wrapper = context.GetWrapper(type);
|
|
|
|
// Handle collections/arrays
|
|
if (value is IEnumerable enumerable && !ReferenceEquals(type, StringType))
|
|
{
|
|
WriteArray(enumerable, wrapper, context, depth);
|
|
return;
|
|
}
|
|
|
|
// Handle complex objects with single-pass reference tracking
|
|
WriteObject(value, wrapper, context, depth, isNested: depth > 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes a non-primitive value with a pre-resolved wrapper (from PropertyTypeWrappers cache).
|
|
/// Avoids GetWrapper dictionary lookup. Handles byte[], dictionary, collection, and complex objects.
|
|
/// </summary>
|
|
private static void WriteValueNonPrimitiveWithWrapper<TOutput>(object value, TypeMetadataWrapper<BinarySerializeTypeMetadata> wrapper, BinarySerializationContext<TOutput> context, int depth)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
var type = wrapper.Metadata.SourceType;
|
|
|
|
// Nullable<T> where T is a value type: boxed value may be a primitive.
|
|
if (type.IsValueType)
|
|
{
|
|
if (TryWritePrimitive(value, value.GetType(), context))
|
|
return;
|
|
}
|
|
|
|
if (depth > context.MaxDepth)
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Null);
|
|
return;
|
|
}
|
|
|
|
// Handle byte arrays specially (value-like, no reference tracking)
|
|
if (value is byte[] byteArray)
|
|
{
|
|
WriteByteArray(byteArray, context);
|
|
return;
|
|
}
|
|
|
|
// Handle dictionaries
|
|
if (value is IDictionary dictionary)
|
|
{
|
|
WriteDictionary(dictionary, context, depth);
|
|
return;
|
|
}
|
|
|
|
// Handle collections/arrays
|
|
if (value is IEnumerable enumerable && !ReferenceEquals(type, StringType))
|
|
{
|
|
WriteArray(enumerable, wrapper, context, depth);
|
|
return;
|
|
}
|
|
|
|
// Handle complex objects with single-pass reference tracking
|
|
WriteObject(value, wrapper, context, depth, isNested: depth > 0);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optimized primitive writer using TypeCode dispatch.
|
|
/// Avoids Nullable.GetUnderlyingType in hot path by using cached type info.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static bool TryWritePrimitive<TOutput>(object value, Type type, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
// Fast path: check TypeCode first (handles most primitives)
|
|
var typeCode = Type.GetTypeCode(type);
|
|
|
|
switch (typeCode)
|
|
{
|
|
case TypeCode.Int32:
|
|
WriteInt32((int)value, context);
|
|
return true;
|
|
case TypeCode.Int64:
|
|
WriteInt64((long)value, context);
|
|
return true;
|
|
case TypeCode.Boolean:
|
|
context.WriteByte((bool)value ? BinaryTypeCode.True : BinaryTypeCode.False);
|
|
return true;
|
|
case TypeCode.Double:
|
|
WriteFloat64Unsafe((double)value, context);
|
|
return true;
|
|
case TypeCode.String:
|
|
WriteString((string)value, context);
|
|
return true;
|
|
case TypeCode.Single:
|
|
WriteFloat32Unsafe((float)value, context);
|
|
return true;
|
|
case TypeCode.Decimal:
|
|
WriteDecimalUnsafe((decimal)value, context);
|
|
return true;
|
|
case TypeCode.DateTime:
|
|
WriteDateTimeUnsafe((DateTime)value, context);
|
|
return true;
|
|
case TypeCode.Byte:
|
|
context.WriteByte(BinaryTypeCode.UInt8);
|
|
context.WriteByte((byte)value);
|
|
return true;
|
|
case TypeCode.Int16:
|
|
WriteInt16Unsafe((short)value, context);
|
|
return true;
|
|
case TypeCode.UInt16:
|
|
WriteUInt16Unsafe((ushort)value, context);
|
|
return true;
|
|
case TypeCode.UInt32:
|
|
WriteUInt32((uint)value, context);
|
|
return true;
|
|
case TypeCode.UInt64:
|
|
WriteUInt64((ulong)value, context);
|
|
return true;
|
|
case TypeCode.SByte:
|
|
context.WriteByte(BinaryTypeCode.Int8);
|
|
context.WriteByte(unchecked((byte)(sbyte)value));
|
|
return true;
|
|
case TypeCode.Char:
|
|
WriteCharUnsafe((char)value, context);
|
|
return true;
|
|
}
|
|
|
|
// Handle special types by reference comparison (faster than type equality)
|
|
if (ReferenceEquals(type, GuidType))
|
|
{
|
|
WriteGuidUnsafe((Guid)value, context);
|
|
return true;
|
|
}
|
|
if (ReferenceEquals(type, DateTimeOffsetType))
|
|
{
|
|
WriteDateTimeOffsetUnsafe((DateTimeOffset)value, context);
|
|
return true;
|
|
}
|
|
if (ReferenceEquals(type, TimeSpanType))
|
|
{
|
|
WriteTimeSpanUnsafe((TimeSpan)value, context);
|
|
return true;
|
|
}
|
|
if (type.IsEnum)
|
|
{
|
|
WriteEnum(value, context);
|
|
return true;
|
|
}
|
|
|
|
// Handle nullable types - use cached check instead of GetUnderlyingType
|
|
// For nullable, value is already unwrapped when boxed, so we can use value.GetType()
|
|
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
|
|
{
|
|
// When boxed, nullable value types are unwrapped to their underlying type
|
|
// So we can just call TryWritePrimitive with the actual runtime type
|
|
return TryWritePrimitive(value, value.GetType(), context);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Optimized Primitive Writers using MemoryMarshal
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteInt32<TOutput>(int value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
if (BinaryTypeCode.TryEncodeTinyInt(value, out var tiny))
|
|
{
|
|
context.WriteByte(tiny);
|
|
return;
|
|
}
|
|
context.WriteByte(BinaryTypeCode.Int32);
|
|
context.WriteVarInt(value);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteInt64<TOutput>(long value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
if (value >= int.MinValue && value <= int.MaxValue)
|
|
{
|
|
WriteInt32((int)value, context);
|
|
return;
|
|
}
|
|
context.WriteByte(BinaryTypeCode.Int64);
|
|
context.WriteVarLong(value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optimized float64 writer using batched write.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteFloat64Unsafe<TOutput>(double value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteTypeCodeAndRaw(BinaryTypeCode.Float64, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optimized float32 writer using batched write.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteFloat32Unsafe<TOutput>(float value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteTypeCodeAndRaw(BinaryTypeCode.Float32, value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optimized decimal writer using direct memory copy of bits.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteDecimalUnsafe<TOutput>(decimal value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Decimal);
|
|
context.WriteDecimalBits(value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optimized DateTime writer.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteDateTimeUnsafe<TOutput>(DateTime value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteByte(BinaryTypeCode.DateTime);
|
|
context.WriteDateTimeBits(value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optimized Guid writer using direct memory copy.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteGuidUnsafe<TOutput>(Guid value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Guid);
|
|
context.WriteGuidBits(value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optimized DateTimeOffset writer.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteDateTimeOffsetUnsafe<TOutput>(DateTimeOffset value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteByte(BinaryTypeCode.DateTimeOffset);
|
|
context.WriteDateTimeOffsetBits(value);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optimized TimeSpan writer.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteTimeSpanUnsafe<TOutput>(TimeSpan value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteTypeCodeAndRaw(BinaryTypeCode.TimeSpan, value.Ticks);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteInt16Unsafe<TOutput>(short value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteTypeCodeAndRaw(BinaryTypeCode.Int16, value);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteUInt16Unsafe<TOutput>(ushort value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteTypeCodeAndRaw(BinaryTypeCode.UInt16, value);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteUInt32<TOutput>(uint value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteByte(BinaryTypeCode.UInt32);
|
|
context.WriteVarUInt(value);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteUInt64<TOutput>(ulong value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteByte(BinaryTypeCode.UInt64);
|
|
context.WriteVarULong(value);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteCharUnsafe<TOutput>(char value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Char);
|
|
context.WriteRaw(value);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteEnum<TOutput>(object value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
// Use direct unboxing instead of Convert.ToInt32 to avoid NumberFormatInfo overhead
|
|
var intValue = GetEnumAsInt32Fast(value);
|
|
if (BinaryTypeCode.TryEncodeTinyInt(intValue, out var tiny))
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Enum);
|
|
context.WriteByte(tiny);
|
|
return;
|
|
}
|
|
context.WriteByte(BinaryTypeCode.Enum);
|
|
context.WriteByte(BinaryTypeCode.Int32);
|
|
context.WriteVarInt(intValue);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Fast enum to int conversion avoiding Convert.ToInt32 overhead.
|
|
/// Handles all common enum underlying types.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static int GetEnumAsInt32Fast(object enumValue)
|
|
{
|
|
var type = enumValue.GetType();
|
|
var underlyingType = type.GetEnumUnderlyingType();
|
|
|
|
if (ReferenceEquals(underlyingType, IntType))
|
|
return (int)enumValue;
|
|
if (ReferenceEquals(underlyingType, typeof(byte)))
|
|
return (byte)enumValue;
|
|
if (ReferenceEquals(underlyingType, typeof(sbyte)))
|
|
return (sbyte)enumValue;
|
|
if (ReferenceEquals(underlyingType, typeof(short)))
|
|
return (short)enumValue;
|
|
if (ReferenceEquals(underlyingType, typeof(ushort)))
|
|
return (ushort)enumValue;
|
|
if (ReferenceEquals(underlyingType, typeof(uint)))
|
|
return unchecked((int)(uint)enumValue);
|
|
|
|
// Fallback for rare cases (long, ulong)
|
|
return Convert.ToInt32(enumValue);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Optimized string writer with FixStr for short strings.
|
|
/// Marker-based interning: write String marker, rewrite to StringInternFirst at end if needed.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteString<TOutput>(string value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
if (value.Length == 0)
|
|
{
|
|
context.WriteByte(BinaryTypeCode.StringEmpty);
|
|
return;
|
|
}
|
|
|
|
if (context.UseStringInterning && context.IsValidForInterningString(value.Length))// && context.CurrentProperty!.UseStringPropertyInterning(context.Options.UseStringInterning))
|
|
{
|
|
ref var interEntry = ref context.GetInternedStringEntry(value, out bool found);
|
|
|
|
if (found && interEntry.CacheIndex >= 0)
|
|
{
|
|
if (interEntry.IsFirstWrite)
|
|
{
|
|
// 1st serialize occurrence of a cached string - write StringInternFirst + cacheIndex + data
|
|
interEntry.IsFirstWrite = false;
|
|
context.WriteByte(BinaryTypeCode.StringInternFirst);
|
|
context.WriteVarUInt((uint)interEntry.CacheIndex);
|
|
context.WriteStringUtf8(value);
|
|
}
|
|
else
|
|
{
|
|
// 2+ serialize occurrence: write index reference
|
|
context.WriteByte(BinaryTypeCode.StringInterned);
|
|
context.WriteVarUInt((uint)interEntry.CacheIndex);
|
|
}
|
|
return;
|
|
}
|
|
// CacheIndex < 0 or not found → single occurrence, fall through to FixStr/String path
|
|
#if DEBUG
|
|
context.OnStringInterned?.Invoke(
|
|
context.CurrentProperty != null ? $"{context.CurrentProperty.DeclaringType.Name}.{context.CurrentProperty.Name}" : null,
|
|
value);
|
|
#endif
|
|
}
|
|
|
|
// Fast path for short strings: check length first (cheap), then ASCII
|
|
// FixStr encodes type+length in single byte for strings <= 31 chars
|
|
var length = value.Length;
|
|
if (length <= BinaryTypeCode.FixStrMaxLength)
|
|
{
|
|
// For short strings, use direct ASCII copy (avoids double validation)
|
|
context.WriteFixStrDirect(value);
|
|
return;
|
|
}
|
|
|
|
// Long strings - standard encoding
|
|
context.WriteByte(BinaryTypeCode.String);
|
|
context.WriteStringUtf8(value);
|
|
}
|
|
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WriteByteArray<TOutput>(byte[] value, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteByte(BinaryTypeCode.ByteArray);
|
|
context.WriteVarUInt((uint)value.Length);
|
|
context.WriteBytes(value);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Complex Type Writers
|
|
|
|
private static void WriteObject<TOutput>(object value, TypeMetadataWrapper<BinarySerializeTypeMetadata> wrapper, BinarySerializationContext<TOutput> context, int depth, bool isNested = false)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
var metadata = wrapper.Metadata;
|
|
|
|
// Wire format:
|
|
// - UseMetadata=false: [Object][props...]
|
|
// - UseMetadata=true, első: [ObjectWithMetadata][propNameHash (4b)][propCount (VarUInt)][hash0..N][props...]
|
|
// - UseMetadata=true, ismételt: [ObjectWithMetadata][propNameHash (4b)][props...]
|
|
// ObjectRef: [ObjectRef][cacheIndex]
|
|
|
|
// UseMetadata: típus regisztrálása (első vs ismételt előfordulás tracking)
|
|
var isFirstMetadataOccurrence = false;
|
|
if (context.UseMetadata)
|
|
{
|
|
isFirstMetadataOccurrence = BinarySerializationContext<TOutput>.RegisterMetadataType(wrapper);
|
|
}
|
|
|
|
// Reference handling: lookup entry from scan pass, check IsFirstWrite
|
|
var cachedObjectCacheIndex = -1; // -1 = not cached, 0+ = cache index for first write
|
|
if (context.UseTypeReferenceHandling(metadata))
|
|
{
|
|
// Lookup by Id (IId types) or by object identity hash (non-IId types)
|
|
// Both use IdAccessorType.Int32 - for non-IId, RefIdGetterInt32 returns RuntimeHelpers.GetHashCode
|
|
switch (metadata.IdAccessorType)
|
|
{
|
|
case IdAccessorType.Int32:
|
|
{
|
|
var id = wrapper.RefIdGetterInt32!(value);
|
|
// For IId: skip default Id (0). For non-IId (hash): hash is never 0 for valid objects
|
|
if ((!metadata.IsIId || id != 0) && wrapper.TryGetEntryInt32(id, out var slotIndex))
|
|
{
|
|
ref var entry = ref wrapper.GetEntryRefInt32(slotIndex);
|
|
if (entry.CacheIndex >= 0)
|
|
{
|
|
if (entry.IsFirstWrite)
|
|
{
|
|
entry.IsFirstWrite = false;
|
|
cachedObjectCacheIndex = entry.CacheIndex;
|
|
}
|
|
else
|
|
{
|
|
// 2+ occurrence → write ObjectRef
|
|
context.WriteByte(BinaryTypeCode.ObjectRef);
|
|
context.WriteVarUInt((uint)entry.CacheIndex);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case IdAccessorType.Int64:
|
|
{
|
|
var id = wrapper.RefIdGetterInt64!(value);
|
|
if (id != 0 && wrapper.TryGetEntryInt64(id, out var slotIndex))
|
|
{
|
|
ref var entry = ref wrapper.GetEntryRefInt64(slotIndex);
|
|
if (entry.CacheIndex >= 0)
|
|
{
|
|
if (entry.IsFirstWrite)
|
|
{
|
|
entry.IsFirstWrite = false;
|
|
cachedObjectCacheIndex = entry.CacheIndex;
|
|
}
|
|
else
|
|
{
|
|
context.WriteByte(BinaryTypeCode.ObjectRef);
|
|
context.WriteVarUInt((uint)entry.CacheIndex);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case IdAccessorType.Guid:
|
|
{
|
|
var id = wrapper.RefIdGetterGuid!(value);
|
|
if (id != Guid.Empty && wrapper.TryGetEntryGuid(id, out var slotIndex))
|
|
{
|
|
ref var entry = ref wrapper.GetEntryRefGuid(slotIndex);
|
|
if (entry.CacheIndex >= 0)
|
|
{
|
|
if (entry.IsFirstWrite)
|
|
{
|
|
entry.IsFirstWrite = false;
|
|
cachedObjectCacheIndex = entry.CacheIndex;
|
|
}
|
|
else
|
|
{
|
|
context.WriteByte(BinaryTypeCode.ObjectRef);
|
|
context.WriteVarUInt((uint)entry.CacheIndex);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Marker kiírása:
|
|
// - Cached object first occurrence: ObjectRefFirst/ObjectWithMetadataRefFirst + cacheIndex
|
|
// - Non-cached: Object/ObjectWithMetadata
|
|
if (context.UseMetadata)
|
|
{
|
|
if (cachedObjectCacheIndex >= 0)
|
|
{
|
|
context.WriteByte(BinaryTypeCode.ObjectWithMetadataRefFirst);
|
|
context.WriteVarUInt((uint)cachedObjectCacheIndex);
|
|
}
|
|
else
|
|
{
|
|
context.WriteByte(BinaryTypeCode.ObjectWithMetadata);
|
|
}
|
|
context.WriteInlineMetadata(wrapper.Metadata, isFirstMetadataOccurrence);
|
|
}
|
|
else
|
|
{
|
|
if (cachedObjectCacheIndex >= 0)
|
|
{
|
|
context.WriteByte(BinaryTypeCode.ObjectRefFirst);
|
|
context.WriteVarUInt((uint)cachedObjectCacheIndex);
|
|
}
|
|
else
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Object);
|
|
}
|
|
}
|
|
|
|
// Write all properties (startIndex=0, including Id for IId types)
|
|
var nextDepth = depth + 1;
|
|
var properties = metadata.Properties;
|
|
var propCount = properties.Length;
|
|
var hasPropertyFilter = context.HasPropertyFilter;
|
|
|
|
if (!context.UseMetadata)
|
|
{
|
|
// Markerless loop: no extra branching per property for the common case.
|
|
// Properties with ExpectedTypeCode write raw values (no type marker, no skip).
|
|
// Properties without ExpectedTypeCode (bool, enum, string, object) use the standard path.
|
|
for (var i = 0; i < propCount; i++)
|
|
{
|
|
var prop = properties[i];
|
|
//context.CurrentProperty = prop;
|
|
|
|
if (prop.ExpectedTypeCode.HasValue)
|
|
{
|
|
WritePropertyMarkerless(value, prop, context);
|
|
}
|
|
else if (hasPropertyFilter && !context.ShouldSerializeProperty(value, prop))
|
|
{
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
}
|
|
else
|
|
{
|
|
WritePropertyOrSkip(value, prop, wrapper, context, nextDepth);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// UseMetadata=true loop — UNCHANGED, zero extra overhead
|
|
for (var i = 0; i < propCount; i++)
|
|
{
|
|
var prop = properties[i];
|
|
//context.CurrentProperty = prop;
|
|
|
|
if (hasPropertyFilter && !context.ShouldSerializeProperty(value, prop))
|
|
{
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
continue;
|
|
}
|
|
|
|
WritePropertyOrSkip(value, prop, wrapper, context, nextDepth);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if a property value is null or default without boxing for value types.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static bool IsPropertyDefaultOrNull(object obj, BinaryPropertyAccessor prop)
|
|
{
|
|
switch (prop.AccessorType)
|
|
{
|
|
case PropertyAccessorType.Int32:
|
|
return prop.GetInt32(obj) == 0;
|
|
case PropertyAccessorType.Int64:
|
|
return prop.GetInt64(obj) == 0L;
|
|
case PropertyAccessorType.Boolean:
|
|
return !prop.GetBoolean(obj);
|
|
case PropertyAccessorType.Double:
|
|
return prop.GetDouble(obj) == 0.0;
|
|
case PropertyAccessorType.Single:
|
|
return prop.GetSingle(obj) == 0f;
|
|
case PropertyAccessorType.Decimal:
|
|
return prop.GetDecimal(obj) == 0m;
|
|
case PropertyAccessorType.Byte:
|
|
return prop.GetByte(obj) == 0;
|
|
case PropertyAccessorType.Int16:
|
|
return prop.GetInt16(obj) == 0;
|
|
case PropertyAccessorType.UInt16:
|
|
return prop.GetUInt16(obj) == 0;
|
|
case PropertyAccessorType.UInt32:
|
|
return prop.GetUInt32(obj) == 0;
|
|
case PropertyAccessorType.UInt64:
|
|
return prop.GetUInt64(obj) == 0;
|
|
case PropertyAccessorType.Guid:
|
|
return prop.GetGuid(obj) == Guid.Empty;
|
|
case PropertyAccessorType.Enum:
|
|
return prop.GetEnumAsInt32(obj) == 0;
|
|
case PropertyAccessorType.DateTime:
|
|
// DateTime default is not typically skipped
|
|
return false;
|
|
default:
|
|
// Object type - use regular getter
|
|
var value = prop.GetValue(obj);
|
|
if (value == null) return true;
|
|
if (prop.PropertyTypeCode == TypeCode.String) return string.IsNullOrEmpty((string)value);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes a property value using typed getters to avoid boxing.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WritePropertyValue<TOutput>(object obj, BinaryPropertyAccessor prop, BinarySerializationContext<TOutput> context, int depth)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
switch (prop.AccessorType)
|
|
{
|
|
case PropertyAccessorType.Int32:
|
|
WriteInt32(prop.GetInt32(obj), context);
|
|
return;
|
|
case PropertyAccessorType.Int64:
|
|
WriteInt64(prop.GetInt64(obj), context);
|
|
return;
|
|
case PropertyAccessorType.Boolean:
|
|
context.WriteByte(prop.GetBoolean(obj) ? BinaryTypeCode.True : BinaryTypeCode.False);
|
|
return;
|
|
case PropertyAccessorType.Double:
|
|
WriteFloat64Unsafe(prop.GetDouble(obj), context);
|
|
return;
|
|
case PropertyAccessorType.Single:
|
|
WriteFloat32Unsafe(prop.GetSingle(obj), context);
|
|
return;
|
|
case PropertyAccessorType.Decimal:
|
|
WriteDecimalUnsafe(prop.GetDecimal(obj), context);
|
|
return;
|
|
case PropertyAccessorType.DateTime:
|
|
WriteDateTimeUnsafe(prop.GetDateTime(obj), context);
|
|
return;
|
|
case PropertyAccessorType.Byte:
|
|
context.WriteByte(BinaryTypeCode.UInt8);
|
|
context.WriteByte(prop.GetByte(obj));
|
|
return;
|
|
case PropertyAccessorType.Int16:
|
|
WriteInt16Unsafe(prop.GetInt16(obj), context);
|
|
return;
|
|
case PropertyAccessorType.UInt16:
|
|
WriteUInt16Unsafe(prop.GetUInt16(obj), context);
|
|
return;
|
|
case PropertyAccessorType.UInt32:
|
|
WriteUInt32(prop.GetUInt32(obj), context);
|
|
return;
|
|
case PropertyAccessorType.UInt64:
|
|
WriteUInt64(prop.GetUInt64(obj), context);
|
|
return;
|
|
case PropertyAccessorType.Guid:
|
|
WriteGuidUnsafe(prop.GetGuid(obj), context);
|
|
return;
|
|
case PropertyAccessorType.Enum:
|
|
var enumValue = prop.GetEnumAsInt32(obj);
|
|
if (BinaryTypeCode.TryEncodeTinyInt(enumValue, out var tiny))
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Enum);
|
|
context.WriteByte(tiny);
|
|
}
|
|
else
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Enum);
|
|
context.WriteByte(BinaryTypeCode.Int32);
|
|
context.WriteVarInt(enumValue);
|
|
}
|
|
return;
|
|
case PropertyAccessorType.String:
|
|
{
|
|
// Fast path: typed getter, no boxing, no Type.GetTypeCode() call
|
|
var strValue = prop.GetString(obj);
|
|
if (strValue != null)
|
|
WriteString(strValue, context);
|
|
else
|
|
context.WriteByte(BinaryTypeCode.Null);
|
|
return;
|
|
}
|
|
default:
|
|
// Fallback to object getter for reference types
|
|
var value = prop.GetValue(obj);
|
|
WriteValue(value, prop.PropertyType, context, depth);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes a property value OR a skip marker if the value is default/null.
|
|
/// Single-pass optimization: checks default + writes value in one operation.
|
|
/// Avoids double getter calls.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WritePropertyOrSkip<TOutput>(object obj, BinaryPropertyAccessor prop, TypeMetadataWrapper<BinarySerializeTypeMetadata> parentWrapper, BinarySerializationContext<TOutput> context, int depth)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
switch (prop.AccessorType)
|
|
{
|
|
case PropertyAccessorType.Int32:
|
|
{
|
|
int value = prop.GetInt32(obj);
|
|
if (value == 0)
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
else
|
|
WriteInt32(value, context);
|
|
return;
|
|
}
|
|
case PropertyAccessorType.Int64:
|
|
{
|
|
long value = prop.GetInt64(obj);
|
|
if (value == 0L)
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
else
|
|
WriteInt64(value, context);
|
|
return;
|
|
}
|
|
case PropertyAccessorType.Boolean:
|
|
{
|
|
bool value = prop.GetBoolean(obj);
|
|
if (!value)
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
else
|
|
context.WriteByte(BinaryTypeCode.True);
|
|
return;
|
|
}
|
|
case PropertyAccessorType.Double:
|
|
{
|
|
double value = prop.GetDouble(obj);
|
|
if (value == 0.0)
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
else
|
|
WriteFloat64Unsafe(value, context);
|
|
return;
|
|
}
|
|
case PropertyAccessorType.Single:
|
|
{
|
|
float value = prop.GetSingle(obj);
|
|
if (value == 0f)
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
else
|
|
WriteFloat32Unsafe(value, context);
|
|
return;
|
|
}
|
|
case PropertyAccessorType.Decimal:
|
|
{
|
|
decimal value = prop.GetDecimal(obj);
|
|
if (value == 0m)
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
else
|
|
WriteDecimalUnsafe(value, context);
|
|
return;
|
|
}
|
|
case PropertyAccessorType.DateTime:
|
|
{
|
|
DateTime value = prop.GetDateTime(obj);
|
|
// DateTime always written (no default skip)
|
|
WriteDateTimeUnsafe(value, context);
|
|
return;
|
|
}
|
|
case PropertyAccessorType.Byte:
|
|
{
|
|
byte value = prop.GetByte(obj);
|
|
if (value == 0)
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
else
|
|
{
|
|
context.WriteByte(BinaryTypeCode.UInt8);
|
|
context.WriteByte(value);
|
|
}
|
|
return;
|
|
}
|
|
case PropertyAccessorType.Int16:
|
|
{
|
|
short value = prop.GetInt16(obj);
|
|
if (value == 0)
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
else
|
|
WriteInt16Unsafe(value, context);
|
|
return;
|
|
}
|
|
case PropertyAccessorType.UInt16:
|
|
{
|
|
ushort value = prop.GetUInt16(obj);
|
|
if (value == 0)
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
else
|
|
WriteUInt16Unsafe(value, context);
|
|
return;
|
|
}
|
|
case PropertyAccessorType.UInt32:
|
|
{
|
|
uint value = prop.GetUInt32(obj);
|
|
if (value == 0)
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
else
|
|
WriteUInt32(value, context);
|
|
return;
|
|
}
|
|
case PropertyAccessorType.UInt64:
|
|
{
|
|
ulong value = prop.GetUInt64(obj);
|
|
if (value == 0)
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
else
|
|
WriteUInt64(value, context);
|
|
return;
|
|
}
|
|
case PropertyAccessorType.Guid:
|
|
{
|
|
Guid value = prop.GetGuid(obj);
|
|
if (value == Guid.Empty)
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
else
|
|
WriteGuidUnsafe(value, context);
|
|
return;
|
|
}
|
|
case PropertyAccessorType.Enum:
|
|
{
|
|
int enumValue = prop.GetEnumAsInt32(obj);
|
|
if (enumValue == 0)
|
|
{
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
}
|
|
else if (BinaryTypeCode.TryEncodeTinyInt(enumValue, out var tiny))
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Enum);
|
|
context.WriteByte(tiny);
|
|
}
|
|
else
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Enum);
|
|
context.WriteByte(BinaryTypeCode.Int32);
|
|
context.WriteVarInt(enumValue);
|
|
}
|
|
return;
|
|
}
|
|
case PropertyAccessorType.String:
|
|
{
|
|
// Fast path: typed getter, no boxing, no Type.GetTypeCode() call
|
|
string? value = prop.GetString(obj);
|
|
if (string.IsNullOrEmpty(value))
|
|
{
|
|
context.WriteByte(value == null ? BinaryTypeCode.PropertySkip : BinaryTypeCode.StringEmpty);
|
|
}
|
|
else
|
|
{
|
|
WriteString(value, context);
|
|
}
|
|
return;
|
|
}
|
|
default:
|
|
{
|
|
// Object type (collection, complex object, byte[], dictionary)
|
|
// Use pre-cached wrapper, fallback to GetWrapper on miss/polymorphism
|
|
var value = prop.GetValue(obj);
|
|
|
|
// SKIP marker only for null (reference types)
|
|
// Empty string, empty collections, etc. are valid values and must be written!
|
|
if (value == null)
|
|
{
|
|
context.WriteByte(BinaryTypeCode.PropertySkip);
|
|
}
|
|
else
|
|
{
|
|
var runtimeType = value.GetType();
|
|
var complexIdx = prop.ComplexPropertyIndex;
|
|
if (complexIdx >= 0)
|
|
{
|
|
var propWrapper = parentWrapper.GetPropertyTypeWrapper(complexIdx, runtimeType);
|
|
if (propWrapper == null)
|
|
{
|
|
propWrapper = context.GetWrapper(runtimeType);
|
|
parentWrapper.SetPropertyTypeWrapper(complexIdx, propWrapper);
|
|
}
|
|
WriteValueNonPrimitiveWithWrapper(value, propWrapper, context, depth);
|
|
}
|
|
else
|
|
{
|
|
// Non-complex in default case (nullable value type, etc.)
|
|
WriteValueNonPrimitive(value, runtimeType, context, depth);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes a property value without type marker byte (markerless mode, UseMetadata=false).
|
|
/// All values are written including defaults — no PropertySkip markers.
|
|
/// Only called for non-nullable value types with ExpectedTypeCode set.
|
|
/// </summary>
|
|
[MethodImpl(MethodImplOptions.AggressiveInlining)]
|
|
private static void WritePropertyMarkerless<TOutput>(object obj, BinaryPropertyAccessor prop, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
switch (prop.AccessorType)
|
|
{
|
|
case PropertyAccessorType.Int32:
|
|
context.WriteVarInt(prop.GetInt32(obj));
|
|
return;
|
|
case PropertyAccessorType.Int64:
|
|
context.WriteVarLong(prop.GetInt64(obj));
|
|
return;
|
|
case PropertyAccessorType.Double:
|
|
context.WriteRaw(prop.GetDouble(obj));
|
|
return;
|
|
case PropertyAccessorType.Single:
|
|
context.WriteRaw(prop.GetSingle(obj));
|
|
return;
|
|
case PropertyAccessorType.Decimal:
|
|
context.WriteDecimalBits(prop.GetDecimal(obj));
|
|
return;
|
|
case PropertyAccessorType.DateTime:
|
|
context.WriteDateTimeBits(prop.GetDateTime(obj));
|
|
return;
|
|
case PropertyAccessorType.Guid:
|
|
context.WriteGuidBits(prop.GetGuid(obj));
|
|
return;
|
|
case PropertyAccessorType.Byte:
|
|
context.WriteByte(prop.GetByte(obj));
|
|
return;
|
|
case PropertyAccessorType.Int16:
|
|
context.WriteRaw(prop.GetInt16(obj));
|
|
return;
|
|
case PropertyAccessorType.UInt16:
|
|
context.WriteRaw(prop.GetUInt16(obj));
|
|
return;
|
|
case PropertyAccessorType.UInt32:
|
|
context.WriteVarUInt(prop.GetUInt32(obj));
|
|
return;
|
|
case PropertyAccessorType.UInt64:
|
|
context.WriteVarULong(prop.GetUInt64(obj));
|
|
return;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Specialized Array Writers
|
|
|
|
/// <summary>
|
|
/// Optimized array writer with specialized paths for primitive arrays.
|
|
/// </summary>
|
|
private static void WriteArray<TOutput>(IEnumerable enumerable, TypeMetadataWrapper<BinarySerializeTypeMetadata> wrapper, BinarySerializationContext<TOutput> context, int depth)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Array);
|
|
var nextDepth = depth + 1;
|
|
|
|
// Use pre-computed metadata — no GetWrapper or GetCollectionElementType needed
|
|
var metadata = wrapper.Metadata;
|
|
var elementType = metadata.CollectionElementType;
|
|
|
|
// Optimized path for primitive arrays
|
|
if (elementType != null && metadata.SourceType.IsArray)
|
|
{
|
|
if (TryWritePrimitiveArray(enumerable, elementType, context))
|
|
return;
|
|
}
|
|
|
|
// For IList, we can write the count directly
|
|
if (enumerable is IList list)
|
|
{
|
|
var count = list.Count;
|
|
context.WriteVarUInt((uint)count);
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
var item = list[i];
|
|
var itemType = item?.GetType() ?? typeof(object);
|
|
WriteValue(item, itemType, context, nextDepth);
|
|
}
|
|
return;
|
|
}
|
|
|
|
// For other IEnumerable, collect first
|
|
var items = new List<object?>();
|
|
foreach (var item in enumerable)
|
|
{
|
|
items.Add(item);
|
|
}
|
|
|
|
context.WriteVarUInt((uint)items.Count);
|
|
foreach (var item in items)
|
|
{
|
|
var itemType = item?.GetType() ?? typeof(object);
|
|
WriteValue(item, itemType, context, nextDepth);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Specialized array writer for primitive arrays using bulk memory operations.
|
|
/// </summary>
|
|
private static bool TryWritePrimitiveArray<TOutput>(IEnumerable enumerable, Type elementType, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
// String array needs context for interning — keep generic path
|
|
if (ReferenceEquals(elementType, StringType) && enumerable is string[] stringArray)
|
|
{
|
|
context.WriteVarUInt((uint)stringArray.Length);
|
|
for (var i = 0; i < stringArray.Length; i++)
|
|
{
|
|
var s = stringArray[i];
|
|
if (s == null)
|
|
context.WriteByte(BinaryTypeCode.Null);
|
|
else
|
|
WriteString(s, context);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// All other primitive arrays — inline write through context (zero virtual dispatch)
|
|
return TryWritePrimitiveArrayCore(enumerable, elementType, context);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Core primitive array writes. Uses context write methods (zero virtual dispatch).
|
|
/// </summary>
|
|
private static bool TryWritePrimitiveArrayCore<TOutput>(IEnumerable enumerable, Type elementType, BinarySerializationContext<TOutput> context)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
// Int32 array - very common case
|
|
if (ReferenceEquals(elementType, IntType) && enumerable is int[] intArray)
|
|
{
|
|
context.WriteVarUInt((uint)intArray.Length);
|
|
context.WriteInt32ArrayOptimized(intArray);
|
|
return true;
|
|
}
|
|
|
|
// Double array - bulk write as raw bytes
|
|
if (ReferenceEquals(elementType, DoubleType) && enumerable is double[] doubleArray)
|
|
{
|
|
context.WriteVarUInt((uint)doubleArray.Length);
|
|
context.WriteDoubleArrayBulk(doubleArray);
|
|
return true;
|
|
}
|
|
|
|
// Long array
|
|
if (ReferenceEquals(elementType, LongType) && enumerable is long[] longArray)
|
|
{
|
|
context.WriteVarUInt((uint)longArray.Length);
|
|
context.WriteLongArrayOptimized(longArray);
|
|
return true;
|
|
}
|
|
|
|
// Float array - bulk write as raw bytes
|
|
if (ReferenceEquals(elementType, FloatType) && enumerable is float[] floatArray)
|
|
{
|
|
context.WriteVarUInt((uint)floatArray.Length);
|
|
context.WriteFloatArrayBulk(floatArray);
|
|
return true;
|
|
}
|
|
|
|
// Bool array - pack as bytes
|
|
if (ReferenceEquals(elementType, BoolType) && enumerable is bool[] boolArray)
|
|
{
|
|
context.WriteVarUInt((uint)boolArray.Length);
|
|
for (var i = 0; i < boolArray.Length; i++)
|
|
{
|
|
context.WriteByte(boolArray[i] ? BinaryTypeCode.True : BinaryTypeCode.False);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Guid array - bulk write
|
|
if (ReferenceEquals(elementType, GuidType) && enumerable is Guid[] guidArray)
|
|
{
|
|
context.WriteVarUInt((uint)guidArray.Length);
|
|
context.WriteGuidArrayBulk(guidArray);
|
|
return true;
|
|
}
|
|
|
|
// Decimal array
|
|
if (ReferenceEquals(elementType, DecimalType) && enumerable is decimal[] decimalArray)
|
|
{
|
|
context.WriteVarUInt((uint)decimalArray.Length);
|
|
for (var i = 0; i < decimalArray.Length; i++)
|
|
{
|
|
WriteDecimalUnsafe(decimalArray[i], context);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// DateTime array
|
|
if (ReferenceEquals(elementType, DateTimeType) && enumerable is DateTime[] dateTimeArray)
|
|
{
|
|
context.WriteVarUInt((uint)dateTimeArray.Length);
|
|
for (var i = 0; i < dateTimeArray.Length; i++)
|
|
{
|
|
WriteDateTimeUnsafe(dateTimeArray[i], context);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static void WriteDictionary<TOutput>(IDictionary dictionary, BinarySerializationContext<TOutput> context, int depth)
|
|
where TOutput : struct, IBinaryOutputBase
|
|
{
|
|
context.WriteByte(BinaryTypeCode.Dictionary);
|
|
context.WriteVarUInt((uint)dictionary.Count);
|
|
var nextDepth = depth + 1;
|
|
|
|
foreach (DictionaryEntry entry in dictionary)
|
|
{
|
|
// Write key
|
|
var keyType = entry.Key?.GetType() ?? typeof(object);
|
|
WriteValue(entry.Key, keyType, context, nextDepth);
|
|
|
|
// Write value
|
|
var valueType = entry.Value?.GetType() ?? typeof(object);
|
|
WriteValue(entry.Value, valueType, context, nextDepth);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Serialization Result
|
|
|
|
// Implementation moved to AcBinarySerializer.BinarySerializationResult.cs
|
|
|
|
#endregion
|
|
|
|
#region Context Pool
|
|
|
|
// Implementation moved to AcBinarySerializer.BinarySerializationContext.cs
|
|
|
|
#endregion
|
|
|
|
#region Serialization Context
|
|
|
|
// Implementation moved to AcBinarySerializer.BinarySerializationContext.cs
|
|
|
|
#endregion
|
|
|
|
#region Type Metadata
|
|
|
|
private static Type? GetCollectionElementType(Type type)
|
|
{
|
|
if (type.IsArray)
|
|
{
|
|
return type.GetElementType();
|
|
}
|
|
|
|
if (type.IsGenericType)
|
|
{
|
|
var args = type.GetGenericArguments();
|
|
if (args.Length == 1)
|
|
{
|
|
return args[0];
|
|
}
|
|
}
|
|
|
|
foreach (var iface in type.GetInterfaces())
|
|
{
|
|
if (iface.IsGenericType && iface.GetGenericTypeDefinition() == typeof(IEnumerable<>))
|
|
{
|
|
return iface.GetGenericArguments()[0];
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
// Type metadata helpers moved to AcBinarySerializer.BinarySerializeTypeMetadata.cs
|
|
|
|
#endregion
|
|
}
|