diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index 7ffd07efb..6ed7f6e71 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -1,5 +1,5 @@ # Refer to https://hub.docker.com/_/microsoft-dotnet-sdk for available versions -FROM mcr.microsoft.com/dotnet/sdk:7.0.101-jammy +FROM mcr.microsoft.com/dotnet/sdk:8.0.300-jammy # Installing mono makes `dotnet test` work without errors even for net472. # But installing it takes a long time, so it's excluded by default. diff --git a/.github/dependabot.yml b/.github/dependabot.yml index b9b0f54a2..7150f8e07 100644 --- a/.github/dependabot.yml +++ b/.github/dependabot.yml @@ -4,6 +4,9 @@ version: 2 updates: - package-ecosystem: nuget + target-branch: develop directory: / schedule: interval: monthly + ignore: + - dependency-name: MessagePack diff --git a/CONTRIBUTORS b/CONTRIBUTORS index 239759454..016f0566e 100644 --- a/CONTRIBUTORS +++ b/CONTRIBUTORS @@ -1,2 +1,2 @@ Yoshifumi Kawai -Andrew Arnott +Andrew Arnott diff --git a/Directory.Packages.props b/Directory.Packages.props index 3ea5aa324..cdeb77b49 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -3,9 +3,7 @@ true true - 0.13.5 - 3.11.0 4.4.0 @@ -21,12 +19,11 @@ - - + @@ -40,29 +37,31 @@ - + - + - - - - - - + - - - + + - + + + + + + + + + @@ -73,4 +72,4 @@ - + \ No newline at end of file diff --git a/LICENSE b/LICENSE index 8519f42f4..eebeb87e0 100644 --- a/LICENSE +++ b/LICENSE @@ -26,6 +26,8 @@ SOFTWARE. lz4net +BSD 2-Clause "Simplified" License + Copyright (c) 2013-2017, Milosz Krajewski All rights reserved. diff --git a/MessagePack.sln b/MessagePack.sln index 4120a5d03..2b743e8e3 100644 --- a/MessagePack.sln +++ b/MessagePack.sln @@ -52,6 +52,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "build", "build", "{301F812B azure-pipelines.yml = azure-pipelines.yml azure-pipelines\build.yml = azure-pipelines\build.yml Directory.Build.props = Directory.Build.props + Directory.Packages.props = Directory.Packages.props global.json = global.json nuget.config = nuget.config stylecop.json = stylecop.json diff --git a/README.md b/README.md index c5dee6f06..294afa514 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# MessagePack for C# (.NET, .NET Core, Unity, Xamarin) +# MessagePack for C# (.NET Framework, .NET 6, Unity, Xamarin) [![NuGet](https://img.shields.io/nuget/v/MessagePack.svg)](https://www.nuget.org/packages/messagepack) [![NuGet](https://img.shields.io/nuget/vpre/MessagePack.svg)](https://www.nuget.org/packages/messagepack) @@ -68,7 +68,7 @@ MessagePack has a compact binary size and a full set of general purpose expressi This library is distributed via NuGet. Special [Unity support](#unity) is available, too. -We target .NET Standard 2.0 with special optimizations for .NET Core 2.1+, making it compatible with most reasonably recent .NET runtimes such as Core 2.0 and later, Framework 4.6.1 and later, Mono 5.4 and later and Unity 2018.3 and later. +We target .NET Standard 2.0 with special optimizations for .NET 6+, making it compatible with most reasonably recent .NET runtimes such as Core 2.0 and later, Framework 4.6.1 and later, Mono 5.4 and later and Unity 2018.3 and later. The library code is pure C# (with Just-In-Time IL code generation on some platforms). ### NuGet packages @@ -1566,7 +1566,7 @@ The `MessagePack.UnityShims` NuGet package is for .NET server-side serialization If you want to share a class between Unity and a server, you can use `SharedProject` or `Reference as Link` or a glob reference (with `LinkBase`), etc. Anyway, you need to share at source-code level. This is a sample project structure using a glob reference (recommended). -- ServerProject(.NET 4.6/.NET Core/.NET Standard) +- ServerProject(.NET Framework 4.6/.NET/.NET Standard) - \[``\] - \[MessagePack\] - \[MessagePack.UnityShims\] @@ -1584,7 +1584,7 @@ For all other Unity targets, AOT is required. If you want to avoid the upfront dynamic generation cost or you need to run on Xamarin or Unity, you need AOT code generation. `mpc` (MessagePackCompiler) is the code generator of MessagePack for C#. mpc uses [Roslyn](https://github.com/dotnet/roslyn) to analyze source code. -First of all, mpc requires [.NET Core 3 Runtime](https://dotnet.microsoft.com/download). The easiest way to acquire and run mpc is as a dotnet tool. +First of all, mpc requires [.NET 6+ Runtime](https://dotnet.microsoft.com/download). The easiest way to acquire and run mpc is as a dotnet tool. ``` dotnet tool install --global MessagePack.Generator @@ -1603,11 +1603,7 @@ Once you have the tool installed, simply invoke using `dotnet mpc` within your r ``` dotnet mpc --help -``` - -Alternatively, you can download mpc from the [Releases](https://github.com/MessagePack-CSharp/MessagePack-CSharp/releases) page, that includes platform native binaries (that don't require a separate dotnet runtime). -``` Usage: mpc [options...] Options: @@ -1677,7 +1673,7 @@ In Unity, you can use MessagePack CodeGen windows at `Windows -> MessagePack -> ![](https://user-images.githubusercontent.com/46207/69414381-f14da400-0d55-11ea-9f8d-9af448d347dc.png) -Install the .NET Core runtime, install mpc (as a .NET Core Tool as described above), and execute `dotnet mpc`. Currently this tool is experimental so please tell me your opinion. +Install the .NET runtime, install mpc (as a .NET Tool as described above), and execute `dotnet mpc`. Currently this tool is experimental so please tell me your opinion. In Xamarin, you can install the [the `MessagePack.MSBuild.Tasks` NuGet package](doc/msbuildtask.md) into your projects to pre-compile fast serialization code and run in environments where JIT compilation is not allowed. diff --git a/SECURITY.md b/SECURITY.md index 74593f78f..aedee6a15 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -2,14 +2,20 @@ ## Supported Versions -| Version | Supported | -| ------- | ------------------ | -| <= 1.7 | :x: | -| 1.8.x | :white_check_mark: | -| 2.0.x | :white_check_mark: | +| Version | Supported | End-of-life date | +| ------- | --------- | ---------------- | +| 1.x | ❌ | +| 2.x | ✅ | 2025-12-31 | +| 3.x | ✅ | not yet determined | + +Each supported major version is only serviced for security issues at its tip. +For example 2.5 will receive updates but 2.4 will not. +3.0 will receive updates until 3.1 is stable, at which point 3.0 will no longer received security updates. ## Reporting a Vulnerability -Please use email to contact the project's main contributors with any vulnerability you become aware of. +Please use [the Security tab](https://github.com/MessagePack-CSharp/MessagePack-CSharp/security) to responsibly report security vulnerabilities. + +Alternatively, email the project's main contributors with any vulnerability you become aware of. - Yoshifumi Kawai ; Andrew Arnott + Yoshifumi Kawai ; Andrew Arnott diff --git a/benchmark/SerializerBenchmark/SerializerBenchmark.csproj b/benchmark/SerializerBenchmark/SerializerBenchmark.csproj index f1fc6457d..a6ea965ee 100644 --- a/benchmark/SerializerBenchmark/SerializerBenchmark.csproj +++ b/benchmark/SerializerBenchmark/SerializerBenchmark.csproj @@ -18,7 +18,6 @@ - diff --git a/global.json b/global.json index cc08211e2..c83e939e8 100644 --- a/global.json +++ b/global.json @@ -1,6 +1,6 @@ { "sdk": { - "version": "7.0.101", + "version": "8.0.300", "rollForward": "patch", "allowPrerelease": false } diff --git a/sandbox/DynamicCodeDumper/DynamicCodeDumper.csproj b/sandbox/DynamicCodeDumper/DynamicCodeDumper.csproj index ef675b4ea..8d1a7c7e2 100644 --- a/sandbox/DynamicCodeDumper/DynamicCodeDumper.csproj +++ b/sandbox/DynamicCodeDumper/DynamicCodeDumper.csproj @@ -70,12 +70,18 @@ Code\ExtensionResult.cs + + Code\MessagePackEventSource.cs + Code\MessagePackSerializerOptions.cs Code\MessagePackSecurity.cs + + Code\SipHash.cs + Code\MonoProtection.cs diff --git a/sandbox/MessagePack.Internal/MessagePack.Internal.csproj b/sandbox/MessagePack.Internal/MessagePack.Internal.csproj index 7bf49a9af..bc7d5d8d4 100644 --- a/sandbox/MessagePack.Internal/MessagePack.Internal.csproj +++ b/sandbox/MessagePack.Internal/MessagePack.Internal.csproj @@ -15,10 +15,6 @@ - - - - diff --git a/sandbox/PerfNetFramework/README.md b/sandbox/PerfNetFramework/README.md index 3c202c2be..f91fa842c 100644 --- a/sandbox/PerfNetFramework/README.md +++ b/sandbox/PerfNetFramework/README.md @@ -10,7 +10,7 @@ When collecting ETL traces, use these settings in the Collect->Run dialog: | Setting | Value | |-------------|-------| -| Command | `dotnet run -c release -p .\sandbox\PerfNetFramework\ -f net461 --no-build` +| Command | `dotnet run -c release -p .\sandbox\PerfNetFramework\ -f net472 --no-build` | Current Dir | `d:\git\messagepack-csharp` (or wherever your enlistment is) | Additional Providers | `*MessagePack-Benchmark` | No V3.X NGen | Checked diff --git a/sandbox/Sandbox/codegen.ps1 b/sandbox/Sandbox/codegen.ps1 index dc51471af..d52201290 100644 --- a/sandbox/Sandbox/codegen.ps1 +++ b/sandbox/Sandbox/codegen.ps1 @@ -1 +1 @@ -dotnet run -f "net7.0" --project "$PSScriptRoot/../../src/MessagePack.Generator/MessagePack.Generator.csproj" -- -i "$PSScriptRoot/../SharedData/SharedData.csproj" -o "$PSScriptRoot/Generated.cs" +dotnet run -f net8.0 --project "$PSScriptRoot/../../src/MessagePack.Generator/MessagePack.Generator.csproj" -- -i "$PSScriptRoot/../SharedData/SharedData.csproj" -o "$PSScriptRoot/Generated.cs" diff --git a/sandbox/TestData.InvalidProject/TestData.InvalidProject.csproj b/sandbox/TestData.InvalidProject/TestData.InvalidProject.csproj index 8164cf6f1..3b149c7b3 100644 --- a/sandbox/TestData.InvalidProject/TestData.InvalidProject.csproj +++ b/sandbox/TestData.InvalidProject/TestData.InvalidProject.csproj @@ -1,6 +1,6 @@  - net461 + net462 diff --git a/sandbox/TestData.InvalidSyntax/TestData.InvalidSyntax.csproj b/sandbox/TestData.InvalidSyntax/TestData.InvalidSyntax.csproj index 0743ce6f8..26e2e25dc 100644 --- a/sandbox/TestData.InvalidSyntax/TestData.InvalidSyntax.csproj +++ b/sandbox/TestData.InvalidSyntax/TestData.InvalidSyntax.csproj @@ -1,6 +1,6 @@  - net461 + net462 diff --git a/sandbox/TestData2/TestData2.csproj b/sandbox/TestData2/TestData2.csproj index 67411bf1f..70735ba36 100644 --- a/sandbox/TestData2/TestData2.csproj +++ b/sandbox/TestData2/TestData2.csproj @@ -1,12 +1,11 @@  - net461 + net462 - diff --git a/sandbox/TestData2/codegen.ps1 b/sandbox/TestData2/codegen.ps1 index 98a829e9c..b964af899 100644 --- a/sandbox/TestData2/codegen.ps1 +++ b/sandbox/TestData2/codegen.ps1 @@ -1 +1 @@ -dotnet run -f "net7.0" --project "$PSScriptRoot/../../src/MessagePack.Generator/MessagePack.Generator.csproj" -- -i "$PSScriptRoot/TestData2.csproj" -o "$PSScriptRoot/Generated.cs" +dotnet run -f net8.0 --project "$PSScriptRoot/../../src/MessagePack.Generator/MessagePack.Generator.csproj" -- -i "$PSScriptRoot/TestData2.csproj" -o "$PSScriptRoot/Generated.cs" diff --git a/src/MessagePack.Generator/MessagePack.Generator.csproj b/src/MessagePack.Generator/MessagePack.Generator.csproj index caa85b2a7..dda450aa6 100644 --- a/src/MessagePack.Generator/MessagePack.Generator.csproj +++ b/src/MessagePack.Generator/MessagePack.Generator.csproj @@ -3,7 +3,7 @@ mpc Exe - net6.0;net7.0 + net6.0;net8.0 true mpc Major @@ -21,6 +21,7 @@ + diff --git a/src/MessagePack.GeneratorCore/CodeAnalysis/TypeCollector.cs b/src/MessagePack.GeneratorCore/CodeAnalysis/TypeCollector.cs index eaf9ef1f6..5f991d514 100644 --- a/src/MessagePack.GeneratorCore/CodeAnalysis/TypeCollector.cs +++ b/src/MessagePack.GeneratorCore/CodeAnalysis/TypeCollector.cs @@ -635,7 +635,14 @@ private ObjectSerializationInfo GetObjectInfo(INamedTypeSymbol type) } var customFormatterAttr = item.GetAttributes().FirstOrDefault(x => x.AttributeClass.ApproximatelyEqual(this.typeReferences.MessagePackFormatterAttribute))?.ConstructorArguments[0].Value as INamedTypeSymbol; - var member = new MemberSerializationInfo(true, isWritable, isReadable, hiddenIntKey++, item.Name, item.Name, item.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), item.Type.ToDisplayString(BinaryWriteFormat), customFormatterAttr?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); + var keyAttribute = item.GetAttributes() + .FirstOrDefault(x => x.AttributeClass.ApproximatelyEqual(this.typeReferences.KeyAttribute)); + + var stringKey = keyAttribute?.ConstructorArguments.Length > 0 + ? keyAttribute.ConstructorArguments[0].Value as string ?? item.Name + : item.Name; + + var member = new MemberSerializationInfo(true, isWritable, isReadable, hiddenIntKey++, stringKey, item.Name, item.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), item.Type.ToDisplayString(BinaryWriteFormat), customFormatterAttr?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); stringMembers.Add(member.StringKey, member); this.CollectCore(item.Type); // recursive collect @@ -661,7 +668,14 @@ private ObjectSerializationInfo GetObjectInfo(INamedTypeSymbol type) } var customFormatterAttr = item.GetAttributes().FirstOrDefault(x => x.AttributeClass.ApproximatelyEqual(this.typeReferences.MessagePackFormatterAttribute))?.ConstructorArguments[0].Value as INamedTypeSymbol; - var member = new MemberSerializationInfo(false, isWritable, isReadable, hiddenIntKey++, item.Name, item.Name, item.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), item.Type.ToDisplayString(BinaryWriteFormat), customFormatterAttr?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); + var keyAttribute = item.GetAttributes() + .FirstOrDefault(x => x.AttributeClass.ApproximatelyEqual(this.typeReferences.KeyAttribute)); + + var stringKey = keyAttribute?.ConstructorArguments.Length > 0 + ? keyAttribute.ConstructorArguments[0].Value as string ?? item.Name + : item.Name; + + var member = new MemberSerializationInfo(false, isWritable, isReadable, hiddenIntKey++, stringKey, item.Name, item.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat), item.Type.ToDisplayString(BinaryWriteFormat), customFormatterAttr?.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat)); stringMembers.Add(member.StringKey, member); this.CollectCore(item.Type); // recursive collect } diff --git a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Annotations/Attributes.cs b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Annotations/Attributes.cs index 227872199..a90a17b69 100644 --- a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Annotations/Attributes.cs +++ b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Annotations/Attributes.cs @@ -83,7 +83,7 @@ public class SerializationConstructorAttribute : Attribute { } - [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface | AttributeTargets.Enum | AttributeTargets.Field | AttributeTargets.Property, AllowMultiple = false, Inherited = true)] + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface | AttributeTargets.Enum | AttributeTargets.Field | AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = false, Inherited = true)] public class MessagePackFormatterAttribute : Attribute { public Type FormatterType { get; private set; } diff --git a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Formatters/DictionaryFormatter.cs b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Formatters/DictionaryFormatter.cs index 2b18677e1..f1550a985 100644 --- a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Formatters/DictionaryFormatter.cs +++ b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Formatters/DictionaryFormatter.cs @@ -78,24 +78,26 @@ public void Serialize(ref MessagePackWriter writer, TDictionary? value, MessageP } else { - IFormatterResolver resolver = options.Resolver; - IMessagePackFormatter? keyFormatter = resolver.GetFormatterWithVerify(); - IMessagePackFormatter? valueFormatter = resolver.GetFormatterWithVerify(); - var len = reader.ReadMapHeader(); TIntermediate dict = this.Create(len, options); options.Security.DepthStep(ref reader); try { - for (int i = 0; i < len; i++) + if (len > 0) { - reader.CancellationToken.ThrowIfCancellationRequested(); - TKey key = keyFormatter.Deserialize(ref reader, options); + IFormatterResolver resolver = options.Resolver; + IMessagePackFormatter? keyFormatter = resolver.GetFormatterWithVerify(); + IMessagePackFormatter? valueFormatter = resolver.GetFormatterWithVerify(); + for (int i = 0; i < len; i++) + { + reader.CancellationToken.ThrowIfCancellationRequested(); + TKey key = keyFormatter.Deserialize(ref reader, options); - TValue value = valueFormatter.Deserialize(ref reader, options); + TValue value = valueFormatter.Deserialize(ref reader, options); - this.Add(dict, i, key, value, options); + this.Add(dict, i, key, value, options); + } } } finally diff --git a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Internal/DynamicAssembly.cs b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Internal/DynamicAssembly.cs index afb7ddb12..7e410e446 100644 --- a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Internal/DynamicAssembly.cs +++ b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Internal/DynamicAssembly.cs @@ -42,7 +42,7 @@ public DynamicAssembly(string moduleName) #if NETFRAMEWORK - public AssemblyBuilder Save() + internal AssemblyBuilder Save() { this.assemblyBuilder.Save(this.moduleName + ".dll"); return this.assemblyBuilder; diff --git a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/MessagePackEventSource.cs b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/MessagePackEventSource.cs new file mode 100644 index 000000000..b850fe1d2 --- /dev/null +++ b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/MessagePackEventSource.cs @@ -0,0 +1,65 @@ +// Copyright (c) All contributors. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. + +#pragma warning disable SA1402 // File may only contain a single type + +using System; +using System.Diagnostics.Tracing; + +namespace MessagePack +{ + [EventSource(Name = "MessagePack")] + internal class MessagePackEventSource : EventSource + { + internal static readonly MessagePackEventSource Instance = new(); + + private const int FormatterDynamicallyGeneratedStartEvent = 1; + private const int FormatterDynamicallyGeneratedStopEvent = 2; + + private MessagePackEventSource() + { + } + + [Event(FormatterDynamicallyGeneratedStartEvent, Task = Tasks.FormatterDynamicallyGenerated, Opcode = EventOpcode.Start)] + public void FormatterDynamicallyGeneratedStart() + { + WriteEvent(FormatterDynamicallyGeneratedStartEvent); + } + + [Event(FormatterDynamicallyGeneratedStopEvent, Task = Tasks.FormatterDynamicallyGenerated, Opcode = EventOpcode.Stop)] + public void FormatterDynamicallyGeneratedStop(string? dataType) + { + WriteEvent(FormatterDynamicallyGeneratedStopEvent, dataType); + } + + /// + /// Names of constants in this class make up the middle term in the event name + /// E.g.: MessagePack/InvokeMethod/Start. + /// + /// Name of this class is important for EventSource. + public static class Tasks + { + public const EventTask FormatterDynamicallyGenerated = (EventTask)1; + } + } + + /// + /// Helper methods for . + /// + /// + /// This methods may contain parameter types that are not allowed on the + /// class itself. + /// If these methods were to be moved to the class itself, + /// eventing would silently fail at runtime, observable only by watching the events (e.g. with PerfView). + /// + internal static class MessagePackEventSourceExtensions + { + internal static void FormatterDynamicallyGeneratedStop(this MessagePackEventSource source, Type dataType) + { + if (source.IsEnabled(EventLevel.Informational, EventKeywords.None)) + { + source.FormatterDynamicallyGeneratedStop(dataType.AssemblyQualifiedName); + } + } + } +} diff --git a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/MessagePackEventSource.cs.meta b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/MessagePackEventSource.cs.meta new file mode 100644 index 000000000..1dc0e6b7e --- /dev/null +++ b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/MessagePackEventSource.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 5440a3bb490544dd87f9f31d0b90f008 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/MessagePackSecurity.cs b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/MessagePackSecurity.cs index bc37b87f0..3a6715299 100644 --- a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/MessagePackSecurity.cs +++ b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/MessagePackSecurity.cs @@ -6,7 +6,9 @@ using System.Collections.Generic; using System.Linq; using System.Reflection; +using System.Runtime.CompilerServices; using System.Runtime.ExceptionServices; +using System.Runtime.InteropServices; using MessagePack.Formatters; using MessagePack.Internal; @@ -31,6 +33,8 @@ public class MessagePackSecurity MaximumObjectGraphDepth = 500, }; + private static readonly SipHash Hash = new(); + private readonly ObjectFallbackEqualityComparer objectFallbackEqualityComparer; private MessagePackSecurity() @@ -138,6 +142,51 @@ public IEqualityComparer GetEqualityComparer() return this.HashCollisionResistant ? GetHashCollisionResistantEqualityComparer() : EqualityComparer.Default; } + private class HashResistantCache + { + internal static readonly IEqualityComparer? EqualityComparer; + + static HashResistantCache() + { + // We have to specially handle some 32-bit types (e.g. float) where multiple in-memory representations should hash to the same value. + // Any type supported by the PrimitiveObjectFormatter should be added here if supporting it as a key in a collection makes sense. + EqualityComparer = + typeof(T) == typeof(bool) ? (IEqualityComparer)CollisionResistantHasherUnmanaged.Instance : + typeof(T) == typeof(char) ? (IEqualityComparer)CollisionResistantHasherUnmanaged.Instance : + typeof(T) == typeof(sbyte) ? (IEqualityComparer)CollisionResistantHasherUnmanaged.Instance : + typeof(T) == typeof(byte) ? (IEqualityComparer)CollisionResistantHasherUnmanaged.Instance : + typeof(T) == typeof(short) ? (IEqualityComparer)CollisionResistantHasherUnmanaged.Instance : + typeof(T) == typeof(ushort) ? (IEqualityComparer)CollisionResistantHasherUnmanaged.Instance : + typeof(T) == typeof(int) ? (IEqualityComparer)CollisionResistantHasherUnmanaged.Instance : + typeof(T) == typeof(uint) ? (IEqualityComparer)CollisionResistantHasherUnmanaged.Instance : + typeof(T) == typeof(long) ? (IEqualityComparer)CollisionResistantHasherUnmanaged.Instance : + typeof(T) == typeof(ulong) ? (IEqualityComparer)CollisionResistantHasherUnmanaged.Instance : + typeof(T) == typeof(Guid) ? (IEqualityComparer)CollisionResistantHasherUnmanaged.Instance : + + // Data types that are managed or have multiple in-memory representations for equivalent values: + typeof(T) == typeof(float) ? (IEqualityComparer)SingleEqualityComparer.Instance : + typeof(T) == typeof(double) ? (IEqualityComparer)DoubleEqualityComparer.Instance : + typeof(T) == typeof(string) ? (IEqualityComparer)StringEqualityComparer.Instance : + typeof(T) == typeof(DateTime) ? (IEqualityComparer)DateTimeEqualityComparer.Instance : + typeof(T) == typeof(DateTimeOffset) ? (IEqualityComparer)DateTimeOffsetEqualityComparer.Instance : + + // Call out each primitive behind an enum explicitly to avoid dynamically generating code. + typeof(T).GetTypeInfo().IsEnum && typeof(T).GetTypeInfo().GetEnumUnderlyingType() is Type underlying ? ( + underlying == typeof(byte) ? CollisionResistantEnumHasher.Instance : + underlying == typeof(sbyte) ? CollisionResistantEnumHasher.Instance : + underlying == typeof(ushort) ? CollisionResistantEnumHasher.Instance : + underlying == typeof(short) ? CollisionResistantEnumHasher.Instance : + underlying == typeof(uint) ? CollisionResistantEnumHasher.Instance : + underlying == typeof(int) ? CollisionResistantEnumHasher.Instance : + underlying == typeof(ulong) ? CollisionResistantEnumHasher.Instance : + underlying == typeof(long) ? CollisionResistantEnumHasher.Instance : + null) : + + // Failsafe. If we don't recognize the type, don't assume we have a good, secure hash function for it. + null; + } + } + /// /// Returns a hash collision resistant equality comparer. /// @@ -145,55 +194,20 @@ public IEqualityComparer GetEqualityComparer() /// A hash collision resistant equality comparer. protected virtual IEqualityComparer GetHashCollisionResistantEqualityComparer() { - IEqualityComparer? result = null; - if (typeof(T).GetTypeInfo().IsEnum) + if (HashResistantCache.EqualityComparer is { } result) { - Type underlyingType = typeof(T).GetTypeInfo().GetEnumUnderlyingType(); - result = - underlyingType == typeof(sbyte) ? CollisionResistantHasher.Instance : - underlyingType == typeof(byte) ? CollisionResistantHasher.Instance : - underlyingType == typeof(short) ? CollisionResistantHasher.Instance : - underlyingType == typeof(ushort) ? CollisionResistantHasher.Instance : - underlyingType == typeof(int) ? CollisionResistantHasher.Instance : - underlyingType == typeof(uint) ? CollisionResistantHasher.Instance : - null; + return result; } - else + + if (typeof(T) == typeof(object)) { - // For anything 32-bits and under, our fallback base secure hasher is usually adequate since it makes the hash unpredictable. - // We should have special implementations for any value that is larger than 32-bits in order to make sure - // that all the data gets hashed securely rather than trivially and predictably compressed into 32-bits before being hashed. - // We also have to specially handle some 32-bit types (e.g. float) where multiple in-memory representations should hash to the same value. - // Any type supported by the PrimitiveObjectFormatter should be added here if supporting it as a key in a collection makes sense. - result = - - // 32-bits or smaller: - typeof(T) == typeof(bool) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(char) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(sbyte) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(byte) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(short) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(ushort) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(int) ? CollisionResistantHasher.Instance : - typeof(T) == typeof(uint) ? CollisionResistantHasher.Instance : - - // Larger than 32-bits (or otherwise require special handling): - typeof(T) == typeof(long) ? (IEqualityComparer)Int64EqualityComparer.Instance : - typeof(T) == typeof(ulong) ? (IEqualityComparer)UInt64EqualityComparer.Instance : - typeof(T) == typeof(float) ? (IEqualityComparer)SingleEqualityComparer.Instance : - typeof(T) == typeof(double) ? (IEqualityComparer)DoubleEqualityComparer.Instance : - typeof(T) == typeof(string) ? (IEqualityComparer)StringEqualityComparer.Instance : - typeof(T) == typeof(Guid) ? (IEqualityComparer)GuidEqualityComparer.Instance : - typeof(T) == typeof(DateTime) ? (IEqualityComparer)DateTimeEqualityComparer.Instance : - typeof(T) == typeof(DateTimeOffset) ? (IEqualityComparer)DateTimeOffsetEqualityComparer.Instance : - typeof(T) == typeof(object) ? (IEqualityComparer)this.objectFallbackEqualityComparer : - null; + return (IEqualityComparer)this.objectFallbackEqualityComparer; } // Any type we don't explicitly whitelist here shouldn't be allowed to use as the key in a hash-based collection since it isn't known to be hash resistant. // This method can of course be overridden to add more hash collision resistant type support, or the deserializing party can indicate that the data is Trusted // so that this method doesn't even get called. - return result ?? throw new TypeAccessException($"No hash-resistant equality comparer available for type: {typeof(T)}"); + throw new TypeAccessException($"No hash-resistant equality comparer available for type: {typeof(T)}"); } /// @@ -233,25 +247,41 @@ public void DepthStep(ref MessagePackReader reader) /// protected virtual MessagePackSecurity Clone() => new MessagePackSecurity(this); + private static int SecureHash(T value) + where T : unmanaged + { + Span span = stackalloc T[1]; + span[0] = value; + return unchecked((int)Hash.Compute(MemoryMarshal.Cast(span))); + } + + private static int SecureHash(ReadOnlySpan data) => unchecked((int)Hash.Compute(data)); + /// /// A hash collision resistant implementation of . /// /// The type of key that will be hashed. - private class CollisionResistantHasher : IEqualityComparer, IEqualityComparer + private abstract class CollisionResistantHasher : IEqualityComparer, IEqualityComparer { - internal static readonly CollisionResistantHasher Instance = new CollisionResistantHasher(); - public bool Equals(T? x, T? y) => EqualityComparer.Default.Equals(x, y); bool IEqualityComparer.Equals(object? x, object? y) => ((IEqualityComparer)EqualityComparer.Default).Equals(x, y); public int GetHashCode(object obj) => this.GetHashCode((T)obj); - public virtual int GetHashCode(T value) => HashCode.Combine(value); + public abstract int GetHashCode(T value); + } + + private class CollisionResistantHasherUnmanaged : CollisionResistantHasher + where T : unmanaged + { + internal static readonly CollisionResistantHasherUnmanaged Instance = new(); + + public override int GetHashCode(T value) => SecureHash(value); } /// - /// A special hash-resistent equality comparer that defers picking the actual implementation + /// A special hash-resistant equality comparer that defers picking the actual implementation /// till it can check the runtime type of each value to be hashed. /// private class ObjectFallbackEqualityComparer : IEqualityComparer, IEqualityComparer @@ -304,116 +334,69 @@ public int GetHashCode(object value) } } - private class UInt64EqualityComparer : CollisionResistantHasher + private class SingleEqualityComparer : CollisionResistantHasherUnmanaged { - internal static new readonly UInt64EqualityComparer Instance = new UInt64EqualityComparer(); - - public override int GetHashCode(ulong value) => HashCode.Combine((uint)(value >> 32), unchecked((uint)value)); - } - - private class Int64EqualityComparer : CollisionResistantHasher - { - internal static new readonly Int64EqualityComparer Instance = new Int64EqualityComparer(); - - public override int GetHashCode(long value) => HashCode.Combine((int)(value >> 32), unchecked((int)value)); - } - - private class SingleEqualityComparer : CollisionResistantHasher - { - internal static new readonly SingleEqualityComparer Instance = new SingleEqualityComparer(); + internal static new readonly SingleEqualityComparer Instance = new(); public override unsafe int GetHashCode(float value) - { - // Special check for 0.0 so that the hash of 0.0 and -0.0 will equal. - if (value == 0.0f) + => base.GetHashCode(value switch { - return HashCode.Combine(0); - } - - // Standardize on the binary representation of NaN prior to hashing. - if (float.IsNaN(value)) - { - value = float.NaN; - } - - int l = *(int*)&value; - return l; - } + 0.0f => 0, // Special check for 0.0 so that the hash of 0.0 and -0.0 will equal. + float.NaN => float.NaN, // Standardize on the binary representation of NaN prior to hashing. + _ => value, + }); } - private class DoubleEqualityComparer : CollisionResistantHasher + private class DoubleEqualityComparer : CollisionResistantHasherUnmanaged { - internal static new readonly DoubleEqualityComparer Instance = new DoubleEqualityComparer(); + internal static new readonly DoubleEqualityComparer Instance = new(); public override unsafe int GetHashCode(double value) - { - // Special check for 0.0 so that the hash of 0.0 and -0.0 will equal. - if (value == 0.0) + => base.GetHashCode(value switch { - return HashCode.Combine(0); - } + 0.0 => 0, // Special check for 0.0 so that the hash of 0.0 and -0.0 will equal. + double.NaN => double.NaN, // Standardize on the binary representation of NaN prior to hashing. + _ => value, + }); + } - // Standardize on the binary representation of NaN prior to hashing. - if (double.IsNaN(value)) - { - value = double.NaN; - } + private class DateTimeEqualityComparer : CollisionResistantHasherUnmanaged + { + internal static new readonly DateTimeEqualityComparer Instance = new(); - long l = *(long*)&value; - return HashCode.Combine((int)(l >> 32), unchecked((int)l)); - } + public override unsafe int GetHashCode(DateTime value) => SecureHash(value.Ticks); } - private class GuidEqualityComparer : CollisionResistantHasher + private class DateTimeOffsetEqualityComparer : CollisionResistantHasherUnmanaged { - internal static new readonly GuidEqualityComparer Instance = new GuidEqualityComparer(); - - public override unsafe int GetHashCode(Guid value) - { - var hash = default(HashCode); - int* pGuid = (int*)&value; - for (int i = 0; i < sizeof(Guid) / sizeof(int); i++) - { - hash.Add(pGuid[i]); - } + internal static new readonly DateTimeOffsetEqualityComparer Instance = new(); - return hash.ToHashCode(); - } + public override unsafe int GetHashCode(DateTimeOffset value) => SecureHash(value.UtcDateTime.Ticks); } private class StringEqualityComparer : CollisionResistantHasher { - internal static new readonly StringEqualityComparer Instance = new StringEqualityComparer(); + internal static readonly StringEqualityComparer Instance = new(); public override int GetHashCode(string value) { -#if NETCOREAPP - // .NET Core already has a secure string hashing function. Just use it. - return value?.GetHashCode() ?? 0; -#else - var hash = default(HashCode); - for (int i = 0; i < value.Length; i++) - { - hash.Add(value[i]); - } - - return hash.ToHashCode(); -#endif + // The Cast call could result in OverflowException at runtime if value is greater than 1bn chars in length. + return SecureHash(MemoryMarshal.Cast(value.AsSpan())); } } - private class DateTimeEqualityComparer : CollisionResistantHasher + private class CollisionResistantEnumHasher : IEqualityComparer, IEqualityComparer + where TUnderlying : unmanaged { - internal static new readonly DateTimeEqualityComparer Instance = new DateTimeEqualityComparer(); + internal static readonly CollisionResistantEnumHasher Instance = new(); - public override unsafe int GetHashCode(DateTime value) => HashCode.Combine((int)(value.Ticks >> 32), unchecked((int)value.Ticks), value.Kind); - } + public bool Equals(TEnum? x, TEnum? y) => EqualityComparer.Default.Equals(x, y); - private class DateTimeOffsetEqualityComparer : CollisionResistantHasher - { - internal static new readonly DateTimeOffsetEqualityComparer Instance = new DateTimeOffsetEqualityComparer(); + public int GetHashCode(TEnum obj) => SecureHash(Unsafe.As(ref obj)); + + bool IEqualityComparer.Equals(object? x, object? y) => x is TEnum e1 && y is TEnum e2 && Equals(e1, e2); - public override unsafe int GetHashCode(DateTimeOffset value) => HashCode.Combine((int)(value.UtcTicks >> 32), unchecked((int)value.UtcTicks)); + int IEqualityComparer.GetHashCode(object obj) => GetHashCode((TEnum)obj); } } } diff --git a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Resolvers/DynamicEnumResolver.cs b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Resolvers/DynamicEnumResolver.cs index 554a0460a..f11be19e2 100644 --- a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Resolvers/DynamicEnumResolver.cs +++ b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Resolvers/DynamicEnumResolver.cs @@ -39,7 +39,7 @@ static DynamicEnumResolver() } #if NETFRAMEWORK - public AssemblyBuilder Save() + internal AssemblyBuilder Save() { return DynamicAssembly.Value.Save(); } @@ -90,40 +90,48 @@ private static TypeInfo BuildType(Type enumType) Type underlyingType = Enum.GetUnderlyingType(enumType); Type formatterType = typeof(IMessagePackFormatter<>).MakeGenericType(enumType); - using (MonoProtection.EnterRefEmitLock()) + MessagePackEventSource.Instance.FormatterDynamicallyGeneratedStart(); + try { - TypeBuilder typeBuilder = DynamicAssembly.Value.DefineType("MessagePack.Formatters." + enumType.FullName!.Replace(".", "_") + "Formatter" + Interlocked.Increment(ref nameSequence), TypeAttributes.Public | TypeAttributes.Sealed, null, new[] { formatterType }); - - // void Serialize(ref MessagePackWriter writer, T value, MessagePackSerializerOptions options); + using (MonoProtection.EnterRefEmitLock()) { - MethodBuilder method = typeBuilder.DefineMethod( - "Serialize", - MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, - null, - new Type[] { typeof(MessagePackWriter).MakeByRefType(), enumType, typeof(MessagePackSerializerOptions) }); - - ILGenerator il = method.GetILGenerator(); - il.Emit(OpCodes.Ldarg_1); - il.Emit(OpCodes.Ldarg_2); - il.Emit(OpCodes.Call, typeof(MessagePackWriter).GetRuntimeMethod(nameof(MessagePackWriter.Write), new[] { underlyingType })!); - il.Emit(OpCodes.Ret); - } + TypeBuilder typeBuilder = DynamicAssembly.Value.DefineType("MessagePack.Formatters." + enumType.FullName!.Replace(".", "_") + "Formatter" + Interlocked.Increment(ref nameSequence), TypeAttributes.Public | TypeAttributes.Sealed, null, new[] { formatterType }); - // T Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options); - { - MethodBuilder method = typeBuilder.DefineMethod( - "Deserialize", - MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, - enumType, - new Type[] { typeof(MessagePackReader).MakeByRefType(), typeof(MessagePackSerializerOptions) }); - - ILGenerator il = method.GetILGenerator(); - il.Emit(OpCodes.Ldarg_1); - il.Emit(OpCodes.Call, typeof(MessagePackReader).GetRuntimeMethod("Read" + underlyingType.Name, Type.EmptyTypes)!); - il.Emit(OpCodes.Ret); - } + // void Serialize(ref MessagePackWriter writer, T value, MessagePackSerializerOptions options); + { + MethodBuilder method = typeBuilder.DefineMethod( + "Serialize", + MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, + null, + new Type[] { typeof(MessagePackWriter).MakeByRefType(), enumType, typeof(MessagePackSerializerOptions) }); + + ILGenerator il = method.GetILGenerator(); + il.Emit(OpCodes.Ldarg_1); + il.Emit(OpCodes.Ldarg_2); + il.Emit(OpCodes.Call, typeof(MessagePackWriter).GetRuntimeMethod(nameof(MessagePackWriter.Write), new[] { underlyingType })!); + il.Emit(OpCodes.Ret); + } - return typeBuilder.CreateTypeInfo()!; + // T Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options); + { + MethodBuilder method = typeBuilder.DefineMethod( + "Deserialize", + MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, + enumType, + new Type[] { typeof(MessagePackReader).MakeByRefType(), typeof(MessagePackSerializerOptions) }); + + ILGenerator il = method.GetILGenerator(); + il.Emit(OpCodes.Ldarg_1); + il.Emit(OpCodes.Call, typeof(MessagePackReader).GetRuntimeMethod("Read" + underlyingType.Name, Type.EmptyTypes)!); + il.Emit(OpCodes.Ret); + } + + return typeBuilder.CreateTypeInfo()!; + } + } + finally + { + MessagePackEventSource.Instance.FormatterDynamicallyGeneratedStop(enumType); } } } diff --git a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Resolvers/DynamicObjectResolver.cs b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Resolvers/DynamicObjectResolver.cs index 125d0069b..6769e0ac6 100644 --- a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Resolvers/DynamicObjectResolver.cs +++ b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Resolvers/DynamicObjectResolver.cs @@ -52,7 +52,7 @@ private DynamicObjectResolver() } #if NETFRAMEWORK - public AssemblyBuilder Save() + internal AssemblyBuilder Save() { return DynamicAssembly.Value.Save(); } @@ -193,7 +193,7 @@ static DynamicContractlessObjectResolver() } #if NETFRAMEWORK - public AssemblyBuilder Save() + internal AssemblyBuilder Save() { return DynamicAssembly.Value.Save(); } @@ -364,102 +364,110 @@ internal static class DynamicObjectTypeBuilder throw new MessagePackSerializationException("Building dynamic formatter only allows public type. Type: " + type.FullName); } - using (MonoProtection.EnterRefEmitLock()) + MessagePackEventSource.Instance.FormatterDynamicallyGeneratedStart(); + try { - Type formatterType = typeof(IMessagePackFormatter<>).MakeGenericType(type); - TypeBuilder typeBuilder = assembly.DefineType("MessagePack.Formatters." + SubtractFullNameRegex.Replace(type.FullName!, string.Empty).Replace(".", "_") + "Formatter" + Interlocked.Increment(ref nameSequence), TypeAttributes.Public | TypeAttributes.Sealed, null, new[] { formatterType }); - - FieldBuilder? stringByteKeysField = null; - Dictionary? customFormatterLookup = null; - - // string key needs string->int mapper for deserialize switch statement - if (serializationInfo.IsStringKey) + using (MonoProtection.EnterRefEmitLock()) { - ConstructorBuilder method = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); - stringByteKeysField = typeBuilder.DefineField("stringByteKeys", typeof(byte[][]), FieldAttributes.Private | FieldAttributes.InitOnly); + Type formatterType = typeof(IMessagePackFormatter<>).MakeGenericType(type); + TypeBuilder typeBuilder = assembly.DefineType("MessagePack.Formatters." + SubtractFullNameRegex.Replace(type.FullName!, string.Empty).Replace(".", "_") + "Formatter" + Interlocked.Increment(ref nameSequence), TypeAttributes.Public | TypeAttributes.Sealed, null, new[] { formatterType }); - ILGenerator il = method.GetILGenerator(); - BuildConstructor(type, serializationInfo, method, stringByteKeysField, il); - customFormatterLookup = BuildCustomFormatterField(typeBuilder, serializationInfo, il); - il.Emit(OpCodes.Ret); - } - else - { - ConstructorBuilder method = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); - ILGenerator il = method.GetILGenerator(); - il.EmitLoadThis(); - il.Emit(OpCodes.Call, objectCtor); - customFormatterLookup = BuildCustomFormatterField(typeBuilder, serializationInfo, il); - il.Emit(OpCodes.Ret); - } + FieldBuilder? stringByteKeysField = null; + Dictionary? customFormatterLookup = null; - { - MethodBuilder method = typeBuilder.DefineMethod( - "Serialize", - MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, - returnType: null, - parameterTypes: new Type[] { typeof(MessagePackWriter).MakeByRefType(), type, typeof(MessagePackSerializerOptions) }); - method.DefineParameter(1, ParameterAttributes.None, "writer"); - method.DefineParameter(2, ParameterAttributes.None, "value"); - method.DefineParameter(3, ParameterAttributes.None, "options"); + // string key needs string->int mapper for deserialize switch statement + if (serializationInfo.IsStringKey) + { + ConstructorBuilder method = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); + stringByteKeysField = typeBuilder.DefineField("stringByteKeys", typeof(byte[][]), FieldAttributes.Private | FieldAttributes.InitOnly); - ILGenerator il = method.GetILGenerator(); - BuildSerialize( - type, - serializationInfo, - il, - () => - { - il.EmitLoadThis(); - il.EmitLdfld(stringByteKeysField!); - }, - (index, member) => - { - if (!customFormatterLookup.TryGetValue(member, out FieldInfo? fi)) - { - return null; - } + ILGenerator il = method.GetILGenerator(); + BuildConstructor(type, serializationInfo, method, stringByteKeysField, il); + customFormatterLookup = BuildCustomFormatterField(typeBuilder, serializationInfo, il); + il.Emit(OpCodes.Ret); + } + else + { + ConstructorBuilder method = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); + ILGenerator il = method.GetILGenerator(); + il.EmitLoadThis(); + il.Emit(OpCodes.Call, objectCtor); + customFormatterLookup = BuildCustomFormatterField(typeBuilder, serializationInfo, il); + il.Emit(OpCodes.Ret); + } - return () => + { + MethodBuilder method = typeBuilder.DefineMethod( + "Serialize", + MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, + returnType: null, + parameterTypes: new Type[] { typeof(MessagePackWriter).MakeByRefType(), type, typeof(MessagePackSerializerOptions) }); + method.DefineParameter(1, ParameterAttributes.None, "writer"); + method.DefineParameter(2, ParameterAttributes.None, "value"); + method.DefineParameter(3, ParameterAttributes.None, "options"); + + ILGenerator il = method.GetILGenerator(); + BuildSerialize( + type, + serializationInfo, + il, + () => { il.EmitLoadThis(); - il.EmitLdfld(fi); - }; - }, - 1); - } + il.EmitLdfld(stringByteKeysField!); + }, + (index, member) => + { + if (!customFormatterLookup.TryGetValue(member, out FieldInfo? fi)) + { + return null; + } - { - MethodBuilder method = typeBuilder.DefineMethod( - "Deserialize", - MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, - type, - new Type[] { refMessagePackReader, typeof(MessagePackSerializerOptions) }); - method.DefineParameter(1, ParameterAttributes.None, "reader"); - method.DefineParameter(2, ParameterAttributes.None, "options"); + return () => + { + il.EmitLoadThis(); + il.EmitLdfld(fi); + }; + }, + 1); + } - ILGenerator il = method.GetILGenerator(); - BuildDeserialize( - type, - serializationInfo, - il, - (index, member) => - { - if (!customFormatterLookup.TryGetValue(member, out FieldInfo? fi)) + { + MethodBuilder method = typeBuilder.DefineMethod( + "Deserialize", + MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual, + type, + new Type[] { refMessagePackReader, typeof(MessagePackSerializerOptions) }); + method.DefineParameter(1, ParameterAttributes.None, "reader"); + method.DefineParameter(2, ParameterAttributes.None, "options"); + + ILGenerator il = method.GetILGenerator(); + BuildDeserialize( + type, + serializationInfo, + il, + (index, member) => { - return null; - } + if (!customFormatterLookup.TryGetValue(member, out FieldInfo? fi)) + { + return null; + } - return () => - { - il.EmitLoadThis(); - il.EmitLdfld(fi); - }; - }, - 1); // firstArgIndex:0 is this. - } + return () => + { + il.EmitLoadThis(); + il.EmitLdfld(fi); + }; + }, + 1); // firstArgIndex:0 is this. + } - return typeBuilder.CreateTypeInfo(); + return typeBuilder.CreateTypeInfo(); + } + } + finally + { + MessagePackEventSource.Instance.FormatterDynamicallyGeneratedStop(type); } } @@ -471,119 +479,127 @@ internal static class DynamicObjectTypeBuilder return null; } - // internal delegate void AnonymousSerializeFunc(byte[][] stringByteKeysField, object[] customFormatters, ref MessagePackWriter writer, T value, MessagePackSerializerOptions options); - // internal delegate T AnonymousDeserializeFunc(object[] customFormatters, ref MessagePackReader reader, MessagePackSerializerOptions options); - var serialize = new DynamicMethod("Serialize", null, new[] { typeof(byte[][]), typeof(object[]), typeof(MessagePackWriter).MakeByRefType(), type, typeof(MessagePackSerializerOptions) }, type, true); - DynamicMethod? deserialize = null; + MessagePackEventSource.Instance.FormatterDynamicallyGeneratedStart(); + try + { + // internal delegate void AnonymousSerializeFunc(byte[][] stringByteKeysField, object[] customFormatters, ref MessagePackWriter writer, T value, MessagePackSerializerOptions options); + // internal delegate T AnonymousDeserializeFunc(object[] customFormatters, ref MessagePackReader reader, MessagePackSerializerOptions options); + var serialize = new DynamicMethod("Serialize", null, new[] { typeof(byte[][]), typeof(object[]), typeof(MessagePackWriter).MakeByRefType(), type, typeof(MessagePackSerializerOptions) }, type, true); + DynamicMethod? deserialize = null; - List stringByteKeysField = new List(); - List serializeCustomFormatters = new List(); - List deserializeCustomFormatters = new List(); + List stringByteKeysField = new List(); + List serializeCustomFormatters = new List(); + List deserializeCustomFormatters = new List(); - if (serializationInfo.IsStringKey) - { - var i = 0; - foreach (ObjectSerializationInfo.EmittableMember item in serializationInfo.Members.Where(x => x.IsReadable)) + if (serializationInfo.IsStringKey) { - stringByteKeysField.Add(Utilities.GetWriterBytes(item.StringKey, (ref MessagePackWriter writer, string? arg) => writer.Write(arg), SequencePool.Shared)); - i++; + var i = 0; + foreach (ObjectSerializationInfo.EmittableMember item in serializationInfo.Members.Where(x => x.IsReadable)) + { + stringByteKeysField.Add(Utilities.GetWriterBytes(item.StringKey, (ref MessagePackWriter writer, string? arg) => writer.Write(arg), SequencePool.Shared)); + i++; + } } - } - foreach (ObjectSerializationInfo.EmittableMember item in serializationInfo.Members.Where(x => x.IsReadable)) - { - MessagePackFormatterAttribute? attr = item.GetMessagePackFormatterAttribute(); - if (attr != null) + foreach (ObjectSerializationInfo.EmittableMember item in serializationInfo.Members.Where(x => x.IsReadable)) { - IMessagePackFormatter formatter = ResolverUtilities.ActivateFormatter(attr.FormatterType, attr.Arguments); - serializeCustomFormatters.Add(formatter); + MessagePackFormatterAttribute? attr = item.GetMessagePackFormatterAttribute(); + if (attr != null) + { + IMessagePackFormatter formatter = ResolverUtilities.ActivateFormatter(attr.FormatterType, attr.Arguments); + serializeCustomFormatters.Add(formatter); + } + else + { + serializeCustomFormatters.Add(null); + } } - else + + foreach (ObjectSerializationInfo.EmittableMember item in serializationInfo.Members) { - serializeCustomFormatters.Add(null); + // not only for writable because for use ctor. + MessagePackFormatterAttribute? attr = item.GetMessagePackFormatterAttribute(); + if (attr != null) + { + IMessagePackFormatter formatter = ResolverUtilities.ActivateFormatter(attr.FormatterType, attr.Arguments); + deserializeCustomFormatters.Add(formatter); + } + else + { + deserializeCustomFormatters.Add(null); + } } - } - foreach (ObjectSerializationInfo.EmittableMember item in serializationInfo.Members) - { - // not only for writable because for use ctor. - MessagePackFormatterAttribute? attr = item.GetMessagePackFormatterAttribute(); - if (attr != null) { - IMessagePackFormatter formatter = ResolverUtilities.ActivateFormatter(attr.FormatterType, attr.Arguments); - deserializeCustomFormatters.Add(formatter); + ILGenerator il = serialize.GetILGenerator(); + BuildSerialize( + type, + serializationInfo, + il, + () => + { + il.EmitLdarg(0); + }, + (index, member) => + { + if (serializeCustomFormatters.Count > 0 && serializeCustomFormatters[index] is object formatter) + { + return () => + { + il.EmitLdarg(1); // read object[] + il.EmitLdc_I4(index); + il.Emit(OpCodes.Ldelem_Ref); // object + il.Emit(OpCodes.Castclass, formatter.GetType()); + }; + } + else + { + return null; + } + }, + 2); // 0, 1 is parameter. } - else + + if (serializationInfo.IsStruct || serializationInfo.BestmatchConstructor != null) { - deserializeCustomFormatters.Add(null); - } - } + deserialize = new DynamicMethod("Deserialize", type, new[] { typeof(object[]), refMessagePackReader, typeof(MessagePackSerializerOptions) }, type, true); - { - ILGenerator il = serialize.GetILGenerator(); - BuildSerialize( - type, - serializationInfo, - il, - () => - { - il.EmitLdarg(0); - }, - (index, member) => - { - if (serializeCustomFormatters.Count > 0 && serializeCustomFormatters[index] is object formatter) + ILGenerator il = deserialize.GetILGenerator(); + BuildDeserialize( + type, + serializationInfo, + il, + (index, member) => { - return () => + if (deserializeCustomFormatters.Count > 0 && deserializeCustomFormatters[index] is object formatter) { - il.EmitLdarg(1); // read object[] - il.EmitLdc_I4(index); - il.Emit(OpCodes.Ldelem_Ref); // object - il.Emit(OpCodes.Castclass, formatter.GetType()); - }; - } - else - { - return null; - } - }, - 2); // 0, 1 is parameter. - } + return () => + { + il.EmitLdarg(0); // read object[] + il.EmitLdc_I4(index); + il.Emit(OpCodes.Ldelem_Ref); // object + il.Emit(OpCodes.Castclass, formatter.GetType()); + }; + } + else + { + return null; + } + }, + 1); + } - if (serializationInfo.IsStruct || serializationInfo.BestmatchConstructor != null) + object serializeDelegate = serialize.CreateDelegate(typeof(AnonymousSerializeFunc<>).MakeGenericType(type)); + object? deserializeDelegate = deserialize?.CreateDelegate(typeof(AnonymousDeserializeFunc<>).MakeGenericType(type)); + var resultFormatter = Activator.CreateInstance( + typeof(AnonymousSerializableFormatter<>).MakeGenericType(type), + new[] { stringByteKeysField.ToArray(), serializeCustomFormatters.ToArray(), deserializeCustomFormatters.ToArray(), serializeDelegate, deserializeDelegate }); + return resultFormatter; + } + finally { - deserialize = new DynamicMethod("Deserialize", type, new[] { typeof(object[]), refMessagePackReader, typeof(MessagePackSerializerOptions) }, type, true); - - ILGenerator il = deserialize.GetILGenerator(); - BuildDeserialize( - type, - serializationInfo, - il, - (index, member) => - { - if (deserializeCustomFormatters.Count > 0 && deserializeCustomFormatters[index] is object formatter) - { - return () => - { - il.EmitLdarg(0); // read object[] - il.EmitLdc_I4(index); - il.Emit(OpCodes.Ldelem_Ref); // object - il.Emit(OpCodes.Castclass, formatter.GetType()); - }; - } - else - { - return null; - } - }, - 1); + MessagePackEventSource.Instance.FormatterDynamicallyGeneratedStop(type); } - - object serializeDelegate = serialize.CreateDelegate(typeof(AnonymousSerializeFunc<>).MakeGenericType(type)); - object? deserializeDelegate = deserialize?.CreateDelegate(typeof(AnonymousDeserializeFunc<>).MakeGenericType(type)); - var resultFormatter = Activator.CreateInstance( - typeof(AnonymousSerializableFormatter<>).MakeGenericType(type), - new[] { stringByteKeysField.ToArray(), serializeCustomFormatters.ToArray(), deserializeCustomFormatters.ToArray(), serializeDelegate, deserializeDelegate }); - return resultFormatter; } private static void BuildConstructor(Type type, ObjectSerializationInfo info, ConstructorInfo method, FieldBuilder stringByteKeysField, ILGenerator il) @@ -1766,7 +1782,7 @@ bool AddEmittableMemberOrIgnore(bool isIntKeyMode, EmittableMember member, bool EmittableMember? CreateEmittableMember(MemberInfo m) { - if (m.IsDefined(typeof(IgnoreMemberAttribute), true) || m.IsDefined(typeof(IgnoreDataMemberAttribute), true)) + if (m.IsDefined(typeof(IgnoreMemberAttribute), true) || m.IsDefined(typeof(IgnoreDataMemberAttribute), true) || m.IsDefined(typeof(NonSerializedAttribute), true)) { return null; } @@ -2019,19 +2035,6 @@ bool AddEmittableMemberOrIgnore(bool isIntKeyMode, EmittableMember member, bool if (len != 0) { - if (len != 1) - { - if (ctorEnumerator != null) - { - ctor = null; - break; - } - else - { - throw new MessagePackDynamicObjectResolverException("duplicate matched constructor parameter name:" + type.FullName + " parameterName:" + item.Name + " parameterType:" + item.ParameterType.Name); - } - } - paramMember = hasKey.First().Value; if (item.ParameterType.IsAssignableFrom(paramMember.Type) && paramMember.IsReadable) { @@ -2309,7 +2312,12 @@ public bool IsValueType /// A bug in /// blocks its ability to invoke property init accessors when in a generic class. /// - internal bool IsProblematicInitProperty => this.PropertyInfo is PropertyInfo property && property.DeclaringType!.IsGenericType && this.IsInitOnly; + internal bool IsProblematicInitProperty +#if NET6_0_OR_GREATER + => false; +#else + => this.PropertyInfo is PropertyInfo property && property.DeclaringType!.IsGenericType && this.IsInitOnly; +#endif public MessagePackFormatterAttribute? GetMessagePackFormatterAttribute() { diff --git a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Resolvers/DynamicUnionResolver.cs b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Resolvers/DynamicUnionResolver.cs index 50c59f401..90e26a755 100644 --- a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Resolvers/DynamicUnionResolver.cs +++ b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/Resolvers/DynamicUnionResolver.cs @@ -58,7 +58,7 @@ private DynamicUnionResolver() } #if NETFRAMEWORK - public AssemblyBuilder Save() + internal AssemblyBuilder Save() { return DynamicAssembly.Value.Save(); } @@ -132,47 +132,55 @@ static FormatterCache() } } - Type formatterType = typeof(IMessagePackFormatter<>).MakeGenericType(type); - using (MonoProtection.EnterRefEmitLock()) + MessagePackEventSource.Instance.FormatterDynamicallyGeneratedStart(); + try { - TypeBuilder typeBuilder = DynamicAssembly.Value.DefineType("MessagePack.Formatters." + SubtractFullNameRegex.Replace(type.FullName!, string.Empty).Replace(".", "_") + "Formatter" + +Interlocked.Increment(ref nameSequence), TypeAttributes.Public | TypeAttributes.Sealed, null, new[] { formatterType }); + Type formatterType = typeof(IMessagePackFormatter<>).MakeGenericType(type); + using (MonoProtection.EnterRefEmitLock()) + { + TypeBuilder typeBuilder = DynamicAssembly.Value.DefineType("MessagePack.Formatters." + SubtractFullNameRegex.Replace(type.FullName!, string.Empty).Replace(".", "_") + "Formatter" + +Interlocked.Increment(ref nameSequence), TypeAttributes.Public | TypeAttributes.Sealed, null, new[] { formatterType }); - FieldBuilder? typeToKeyAndJumpMap = null; // Dictionary> - FieldBuilder? keyToJumpMap = null; // Dictionary + FieldBuilder? typeToKeyAndJumpMap = null; // Dictionary> + FieldBuilder? keyToJumpMap = null; // Dictionary - // create map dictionary - { - ConstructorBuilder method = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); - typeToKeyAndJumpMap = typeBuilder.DefineField("typeToKeyAndJumpMap", typeof(Dictionary>), FieldAttributes.Private | FieldAttributes.InitOnly); - keyToJumpMap = typeBuilder.DefineField("keyToJumpMap", typeof(Dictionary), FieldAttributes.Private | FieldAttributes.InitOnly); + // create map dictionary + { + ConstructorBuilder method = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, Type.EmptyTypes); + typeToKeyAndJumpMap = typeBuilder.DefineField("typeToKeyAndJumpMap", typeof(Dictionary>), FieldAttributes.Private | FieldAttributes.InitOnly); + keyToJumpMap = typeBuilder.DefineField("keyToJumpMap", typeof(Dictionary), FieldAttributes.Private | FieldAttributes.InitOnly); - ILGenerator il = method.GetILGenerator(); - BuildConstructor(type, unionAttrs, method, typeToKeyAndJumpMap, keyToJumpMap, il); - } + ILGenerator il = method.GetILGenerator(); + BuildConstructor(type, unionAttrs, method, typeToKeyAndJumpMap, keyToJumpMap, il); + } - { - MethodBuilder method = typeBuilder.DefineMethod( - "Serialize", - MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.NewSlot, - null, - new Type[] { typeof(MessagePackWriter).MakeByRefType(), type, typeof(MessagePackSerializerOptions) }); - - ILGenerator il = method.GetILGenerator(); - BuildSerialize(type, unionAttrs, method, typeToKeyAndJumpMap, il); - } + { + MethodBuilder method = typeBuilder.DefineMethod( + "Serialize", + MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.NewSlot, + null, + new Type[] { typeof(MessagePackWriter).MakeByRefType(), type, typeof(MessagePackSerializerOptions) }); + + ILGenerator il = method.GetILGenerator(); + BuildSerialize(type, unionAttrs, method, typeToKeyAndJumpMap, il); + } - { - MethodBuilder method = typeBuilder.DefineMethod( - "Deserialize", - MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.NewSlot, - type, - new Type[] { refMessagePackReader, typeof(MessagePackSerializerOptions) }); - - ILGenerator il = method.GetILGenerator(); - BuildDeserialize(type, unionAttrs, method, keyToJumpMap, il); - } + { + MethodBuilder method = typeBuilder.DefineMethod( + "Deserialize", + MethodAttributes.Public | MethodAttributes.Final | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.NewSlot, + type, + new Type[] { refMessagePackReader, typeof(MessagePackSerializerOptions) }); + + ILGenerator il = method.GetILGenerator(); + BuildDeserialize(type, unionAttrs, method, keyToJumpMap, il); + } - return typeBuilder.CreateTypeInfo(); + return typeBuilder.CreateTypeInfo(); + } + } + finally + { + MessagePackEventSource.Instance.FormatterDynamicallyGeneratedStop(type); } } diff --git a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/SipHash.cs b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/SipHash.cs new file mode 100644 index 000000000..4cc256c0c --- /dev/null +++ b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/SipHash.cs @@ -0,0 +1,287 @@ +// Copyright (c) All contributors. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. + +//// Originally from: https://github.com/paya-cz/siphash +//// Author: Pavel Werl +//// License: Public Domain +//// SipHash website: https://131002.net/siphash/ + +using System; +using System.Buffers; +using System.Buffers.Binary; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security.Cryptography; + +namespace MessagePack +{ + /// + /// Implements the SipHash pseudo-random function. + /// + /// + /// This class is immutable and thread-safe. + /// + internal class SipHash + { + /// + /// Part of the initial 256-bit internal state. + /// + private readonly ulong initialState0; + + /// + /// Part of the initial 256-bit internal state. + /// + private readonly ulong initialState1; + + /// Initializes a new instance of the class using a random key. + public SipHash() + { + using RandomNumberGenerator rng = RandomNumberGenerator.Create(); +#if SPAN_BUILTIN + Span key = stackalloc byte[16]; + rng.GetBytes(key); +#else + byte[] buffer = ArrayPool.Shared.Rent(16); + rng.GetBytes(buffer, 0, 16); + Span key = buffer; +#endif + + this.initialState0 = 0x736f6d6570736575UL ^ BinaryPrimitives.ReadUInt64LittleEndian(key); + this.initialState1 = 0x646f72616e646f6dUL ^ BinaryPrimitives.ReadUInt64LittleEndian(key.Slice(sizeof(ulong))); + +#if !SPAN_BUILTIN + ArrayPool.Shared.Return(buffer); +#endif + } + + /// Initializes a new instance of the class using the specified 128-bit key. + /// Key for the SipHash pseudo-random function. Must be exactly 16 bytes long. + /// Thrown when is not exactly 16 bytes long (128 bits). + public SipHash(ReadOnlySpan key) + { + if (key.Length != 16) + { + throw new ArgumentException("SipHash key must be exactly 128-bit long (16 bytes).", nameof(key)); + } + + this.initialState0 = 0x736f6d6570736575UL ^ BinaryPrimitives.ReadUInt64LittleEndian(key); + this.initialState1 = 0x646f72616e646f6dUL ^ BinaryPrimitives.ReadUInt64LittleEndian(key.Slice(sizeof(ulong))); + } + + /// + /// Gets a 128-bit SipHash key. + /// + /// The 16-byte buffer that receives the key originally provided to the constructor. + public void GetKey(Span key) + { + if (key.Length != 16) + { + throw new ArgumentException("SipHash key must be exactly 128-bit long (16 bytes).", nameof(key)); + } + + BinaryPrimitives.WriteUInt64LittleEndian(key, this.initialState0 ^ 0x736f6d6570736575UL); + BinaryPrimitives.WriteUInt64LittleEndian(key.Slice(sizeof(ulong)), this.initialState1 ^ 0x646f72616e646f6dUL); + } + + /// Computes 64-bit SipHash tag for the specified message. + /// The byte array for which to computer SipHash tag. + /// Returns 64-bit (8 bytes) SipHash tag. + public long Compute(ReadOnlySpan data) + { + unchecked + { + // SipHash internal state + ulong v0 = this.initialState0; + ulong v1 = this.initialState1; + + // It is faster to load the initialStateX fields from memory again than to reference v0 and v1: + ulong v2 = 0x1F160A001E161714UL ^ this.initialState0; + ulong v3 = 0x100A160317100A1EUL ^ this.initialState1; + + // We process data in 64-bit blocks + ulong block; + + // The last 64-bit block of data + int finalBlockPosition = data.Length & ~7; + + // Process the input data in blocks of 64 bits + for (int blockPosition = 0; blockPosition < finalBlockPosition; blockPosition += sizeof(ulong)) + { + block = MemoryMarshal.Read(data.Slice(blockPosition)); + + v3 ^= block; + + // Round 1 + v0 += v1; + v2 += v3; + v1 = v1 << 13 | v1 >> 51; + v3 = v3 << 16 | v3 >> 48; + v1 ^= v0; + v3 ^= v2; + v0 = v0 << 32 | v0 >> 32; + v2 += v1; + v0 += v3; + v1 = v1 << 17 | v1 >> 47; + v3 = v3 << 21 | v3 >> 43; + v1 ^= v2; + v3 ^= v0; + v2 = v2 << 32 | v2 >> 32; + + // Round 2 + v0 += v1; + v2 += v3; + v1 = v1 << 13 | v1 >> 51; + v3 = v3 << 16 | v3 >> 48; + v1 ^= v0; + v3 ^= v2; + v0 = v0 << 32 | v0 >> 32; + v2 += v1; + v0 += v3; + v1 = v1 << 17 | v1 >> 47; + v3 = v3 << 21 | v3 >> 43; + v1 ^= v2; + v3 ^= v0; + v2 = v2 << 32 | v2 >> 32; + + v0 ^= block; + } + + // Load the remaining bytes + block = (ulong)data.Length << 56; + switch (data.Length & 7) + { + case 7: + block |= MemoryMarshal.Read(data.Slice(finalBlockPosition)) | (ulong)MemoryMarshal.Read(data.Slice(finalBlockPosition + 4)) << 32 | (ulong)data[finalBlockPosition + 6] << 48; + break; + case 6: + block |= MemoryMarshal.Read(data.Slice(finalBlockPosition)) | (ulong)MemoryMarshal.Read(data.Slice(finalBlockPosition + 4)) << 32; + break; + case 5: + block |= MemoryMarshal.Read(data.Slice(finalBlockPosition)) | (ulong)data[finalBlockPosition + 4] << 32; + break; + case 4: + block |= MemoryMarshal.Read(data.Slice(finalBlockPosition)); + break; + case 3: + block |= MemoryMarshal.Read(data.Slice(finalBlockPosition)) | (ulong)data[finalBlockPosition + 2] << 16; + break; + case 2: + block |= MemoryMarshal.Read(data.Slice(finalBlockPosition)); + break; + case 1: + block |= data[finalBlockPosition]; + break; + } + + // Process the final block + { + v3 ^= block; + + // Round 1 + v0 += v1; + v2 += v3; + v1 = v1 << 13 | v1 >> 51; + v3 = v3 << 16 | v3 >> 48; + v1 ^= v0; + v3 ^= v2; + v0 = v0 << 32 | v0 >> 32; + v2 += v1; + v0 += v3; + v1 = v1 << 17 | v1 >> 47; + v3 = v3 << 21 | v3 >> 43; + v1 ^= v2; + v3 ^= v0; + v2 = v2 << 32 | v2 >> 32; + + // Round 2 + v0 += v1; + v2 += v3; + v1 = v1 << 13 | v1 >> 51; + v3 = v3 << 16 | v3 >> 48; + v1 ^= v0; + v3 ^= v2; + v0 = v0 << 32 | v0 >> 32; + v2 += v1; + v0 += v3; + v1 = v1 << 17 | v1 >> 47; + v3 = v3 << 21 | v3 >> 43; + v1 ^= v2; + v3 ^= v0; + v2 = v2 << 32 | v2 >> 32; + + v0 ^= block; + v2 ^= 0xff; + } + + // 4 finalization rounds + { + // Round 1 + v0 += v1; + v2 += v3; + v1 = v1 << 13 | v1 >> 51; + v3 = v3 << 16 | v3 >> 48; + v1 ^= v0; + v3 ^= v2; + v0 = v0 << 32 | v0 >> 32; + v2 += v1; + v0 += v3; + v1 = v1 << 17 | v1 >> 47; + v3 = v3 << 21 | v3 >> 43; + v1 ^= v2; + v3 ^= v0; + v2 = v2 << 32 | v2 >> 32; + + // Round 2 + v0 += v1; + v2 += v3; + v1 = v1 << 13 | v1 >> 51; + v3 = v3 << 16 | v3 >> 48; + v1 ^= v0; + v3 ^= v2; + v0 = v0 << 32 | v0 >> 32; + v2 += v1; + v0 += v3; + v1 = v1 << 17 | v1 >> 47; + v3 = v3 << 21 | v3 >> 43; + v1 ^= v2; + v3 ^= v0; + v2 = v2 << 32 | v2 >> 32; + + // Round 3 + v0 += v1; + v2 += v3; + v1 = v1 << 13 | v1 >> 51; + v3 = v3 << 16 | v3 >> 48; + v1 ^= v0; + v3 ^= v2; + v0 = v0 << 32 | v0 >> 32; + v2 += v1; + v0 += v3; + v1 = v1 << 17 | v1 >> 47; + v3 = v3 << 21 | v3 >> 43; + v1 ^= v2; + v3 ^= v0; + v2 = v2 << 32 | v2 >> 32; + + // Round 4 + v0 += v1; + v2 += v3; + v1 = v1 << 13 | v1 >> 51; + v3 = v3 << 16 | v3 >> 48; + v1 ^= v0; + v3 ^= v2; + v0 = v0 << 32 | v0 >> 32; + v2 += v1; + v0 += v3; + v1 = v1 << 17 | v1 >> 47; + v3 = v3 << 21 | v3 >> 43; + v1 ^= v2; + v3 ^= v0; + v2 = v2 << 32 | v2 >> 32; + } + + return (long)((v0 ^ v1) ^ (v2 ^ v3)); + } + } + } +} diff --git a/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/SipHash.cs.meta b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/SipHash.cs.meta new file mode 100644 index 000000000..b8ac22068 --- /dev/null +++ b/src/MessagePack.UnityClient/Assets/Scripts/MessagePack/SipHash.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c78b7a26485c4131ae8bcfae61e01435 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/DataContractTest.cs b/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/DataContractTest.cs index 837f4e0f1..4aeff01bb 100644 --- a/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/DataContractTest.cs +++ b/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/DataContractTest.cs @@ -195,6 +195,33 @@ public class Detail : IEquatable public bool Equals(Detail other) => other != null && this.B1 == other.B1 && this.B2 == other.B2; } + [Fact] + public void Serialize_WithNonSerializedAttribute() + { + var mc = new ClassWithOldSchoolNonSerializedAttribute + { + PublicField = 1, + IgnoredPublicField = 2, + }; + + var options = ContractlessStandardResolverAllowPrivate.Options; + var bin = MessagePackSerializer.Serialize(mc, options); + var mc2 = MessagePackSerializer.Deserialize(bin, options); + + mc2.PublicField.Is(1); + mc2.IgnoredPublicField.Is(0); + + MessagePackSerializer.ConvertToJson(bin).Is(@"{""PublicField"":1}"); + } + + public class ClassWithOldSchoolNonSerializedAttribute + { + public int PublicField; + + [NonSerialized] + public int IgnoredPublicField; + } + #if !UNITY_2018_3_OR_NEWER [Fact] diff --git a/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/DictionaryTest.cs b/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/DictionaryTest.cs index cc4d3b078..9fc6fdc5c 100644 --- a/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/DictionaryTest.cs +++ b/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/DictionaryTest.cs @@ -53,12 +53,14 @@ public void InterfaceDictionaryTest() public void ConcurrentDictionaryTest() { var cd = new ConcurrentDictionary(); + ConcurrentDictionary conv = this.Convert(cd); + conv.Count.Is(0); cd.TryAdd(1, 100); cd.TryAdd(2, 200); cd.TryAdd(3, 300); - ConcurrentDictionary conv = this.Convert(cd); + conv = this.Convert(cd); conv[1].Is(100); conv[2].Is(200); conv[3].Is(300); diff --git a/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/MessagePackSecurityTests.cs b/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/MessagePackSecurityTests.cs index d89411e74..74121e5d7 100644 --- a/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/MessagePackSecurityTests.cs +++ b/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/MessagePackSecurityTests.cs @@ -125,11 +125,8 @@ public void EqualityComparer_Enums() Assert.NotNull(MessagePackSecurity.UntrustedData.GetEqualityComparer()); Assert.NotNull(MessagePackSecurity.UntrustedData.GetEqualityComparer()); Assert.NotNull(MessagePackSecurity.UntrustedData.GetEqualityComparer()); - - // Supporting enums with backing integers that exceed 32-bits would likely require Ref.Emit of new types - // since C# doesn't let us cast T to the underlying int type. - Assert.Throws(() => MessagePackSecurity.UntrustedData.GetEqualityComparer()); - Assert.Throws(() => MessagePackSecurity.UntrustedData.GetEqualityComparer()); + Assert.NotNull(MessagePackSecurity.UntrustedData.GetEqualityComparer()); + Assert.NotNull(MessagePackSecurity.UntrustedData.GetEqualityComparer()); } [Fact] diff --git a/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/SipHashTests.cs b/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/SipHashTests.cs new file mode 100644 index 000000000..1e439cdab --- /dev/null +++ b/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/SipHashTests.cs @@ -0,0 +1,117 @@ +// Copyright (c) All contributors. All rights reserved. +// Licensed under the MIT license. See LICENSE file in the project root for full license information. + +using System; +using System.Linq; +using MessagePack; +using Xunit; + +public class SipHashTests +{ + // Test battery taken from: https://github.com/veorq/SipHash/blob/master/main.c + private static readonly uint[][] Vectors = new[] + { + new uint[] { 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72 }, + new uint[] { 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74 }, + new uint[] { 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d }, + new uint[] { 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85 }, + new uint[] { 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf }, + new uint[] { 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18 }, + new uint[] { 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb }, + new uint[] { 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab }, + new uint[] { 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93 }, + new uint[] { 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e }, + new uint[] { 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a }, + new uint[] { 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4 }, + new uint[] { 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75 }, + new uint[] { 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14 }, + new uint[] { 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7 }, + new uint[] { 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1 }, + new uint[] { 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f }, + new uint[] { 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69 }, + new uint[] { 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b }, + new uint[] { 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb }, + new uint[] { 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe }, + new uint[] { 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0 }, + new uint[] { 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93 }, + new uint[] { 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8 }, + new uint[] { 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8 }, + new uint[] { 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc }, + new uint[] { 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17 }, + new uint[] { 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f }, + new uint[] { 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde }, + new uint[] { 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6 }, + new uint[] { 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad }, + new uint[] { 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32 }, + new uint[] { 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71 }, + new uint[] { 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7 }, + new uint[] { 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12 }, + new uint[] { 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15 }, + new uint[] { 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31 }, + new uint[] { 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02 }, + new uint[] { 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca }, + new uint[] { 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a }, + new uint[] { 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e }, + new uint[] { 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad }, + new uint[] { 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18 }, + new uint[] { 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4 }, + new uint[] { 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9 }, + new uint[] { 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9 }, + new uint[] { 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb }, + new uint[] { 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0 }, + new uint[] { 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6 }, + new uint[] { 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7 }, + new uint[] { 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee }, + new uint[] { 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1 }, + new uint[] { 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a }, + new uint[] { 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81 }, + new uint[] { 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f }, + new uint[] { 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24 }, + new uint[] { 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7 }, + new uint[] { 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea }, + new uint[] { 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60 }, + new uint[] { 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66 }, + new uint[] { 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c }, + new uint[] { 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f }, + new uint[] { 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5 }, + new uint[] { 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95 }, + }; + + [Fact] + public void TestBattery_Aligned() => TestHelper(false); + + [Fact] + public void TestBattery_Unaligned() => TestHelper(true); + + private void TestHelper(bool unaligned) + { + // 128-bit key + byte[] key = Enumerable.Range(0, 16).Select(x => (byte)x).ToArray(); + + // SipHash initialized with the key + SipHash prf = new SipHash(key); + + // Perform the test battery + Span message = new byte[Vectors.Length + 1]; + if (unaligned) + { + message = message.Slice(1); + } + + for (int i = 0; i < Vectors.Length; i++) + { + message[i] = (byte)i; + + // Compute the tag + long actual = prf.Compute(message.Slice(0, i)); + + // Get the target tag + long expected = BitConverter.ToInt64(Vectors[i].Select(x => (byte)x).ToArray(), 0); + + if (expected != actual) + { + throw new Exception($"Test vector failed for {i:N}-byte message!"); + } + } + } +} diff --git a/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/SipHashTests.cs.meta b/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/SipHashTests.cs.meta new file mode 100644 index 000000000..996b7da44 --- /dev/null +++ b/src/MessagePack.UnityClient/Assets/Scripts/Tests/ShareTests/SipHashTests.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c71df5af28304fe2991b6aaba359db90 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/src/MessagePack/MessagePack.csproj b/src/MessagePack/MessagePack.csproj index 390323add..31946ee2f 100644 --- a/src/MessagePack/MessagePack.csproj +++ b/src/MessagePack/MessagePack.csproj @@ -1,10 +1,10 @@  - netstandard2.0;net6.0 + netstandard2.0;net6.0;net472 $(NoWarn);CS0649 True - $(DefineConstants);SPAN_BUILTIN + $(DefineConstants);SPAN_BUILTIN True 9.0 @@ -42,6 +42,10 @@ + + + + diff --git a/src/MessagePack/net472/PublicAPI.Shipped.txt b/src/MessagePack/net472/PublicAPI.Shipped.txt new file mode 100644 index 000000000..2893efd85 --- /dev/null +++ b/src/MessagePack/net472/PublicAPI.Shipped.txt @@ -0,0 +1,1185 @@ +#nullable enable +MessagePack.ExtensionHeader +MessagePack.ExtensionHeader.ExtensionHeader(sbyte typeCode, int length) -> void +MessagePack.ExtensionHeader.ExtensionHeader(sbyte typeCode, uint length) -> void +MessagePack.ExtensionHeader.Length.get -> uint +MessagePack.ExtensionHeader.TypeCode.get -> sbyte +MessagePack.ExtensionResult +MessagePack.ExtensionResult.Data.get -> System.Buffers.ReadOnlySequence +MessagePack.ExtensionResult.ExtensionResult(sbyte typeCode, System.Buffers.ReadOnlySequence data) -> void +MessagePack.ExtensionResult.ExtensionResult(sbyte typeCode, System.Memory data) -> void +MessagePack.ExtensionResult.Header.get -> MessagePack.ExtensionHeader +MessagePack.ExtensionResult.TypeCode.get -> sbyte +MessagePack.FormatterNotRegisteredException +MessagePack.FormatterNotRegisteredException.FormatterNotRegisteredException(string? message) -> void +MessagePack.FormatterResolverExtensions +MessagePack.Formatters.ArrayFormatter +MessagePack.Formatters.ArrayFormatter.ArrayFormatter() -> void +MessagePack.Formatters.ArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T[]? +MessagePack.Formatters.ArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ArraySegmentFormatter +MessagePack.Formatters.ArraySegmentFormatter.ArraySegmentFormatter() -> void +MessagePack.Formatters.ArraySegmentFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.ArraySegment +MessagePack.Formatters.ArraySegmentFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.ArraySegment value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.BigIntegerFormatter +MessagePack.Formatters.BigIntegerFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Numerics.BigInteger +MessagePack.Formatters.BigIntegerFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Numerics.BigInteger value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.BitArrayFormatter +MessagePack.Formatters.BitArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Collections.BitArray? +MessagePack.Formatters.BitArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Collections.BitArray? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.BooleanArrayFormatter +MessagePack.Formatters.BooleanArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> bool[]? +MessagePack.Formatters.BooleanArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, bool[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.BooleanFormatter +MessagePack.Formatters.BooleanFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> bool +MessagePack.Formatters.BooleanFormatter.Serialize(ref MessagePack.MessagePackWriter writer, bool value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ByteArrayFormatter +MessagePack.Formatters.ByteArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> byte[]? +MessagePack.Formatters.ByteArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, byte[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ByteArraySegmentFormatter +MessagePack.Formatters.ByteArraySegmentFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.ArraySegment +MessagePack.Formatters.ByteArraySegmentFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.ArraySegment value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ByteFormatter +MessagePack.Formatters.ByteFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> byte +MessagePack.Formatters.ByteFormatter.Serialize(ref MessagePack.MessagePackWriter writer, byte value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.CharArrayFormatter +MessagePack.Formatters.CharArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> char[]? +MessagePack.Formatters.CharArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, char[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.CharFormatter +MessagePack.Formatters.CharFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> char +MessagePack.Formatters.CharFormatter.Serialize(ref MessagePack.MessagePackWriter writer, char value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.CollectionFormatterBase +MessagePack.Formatters.CollectionFormatterBase.CollectionFormatterBase() -> void +MessagePack.Formatters.CollectionFormatterBase +MessagePack.Formatters.CollectionFormatterBase.CollectionFormatterBase() -> void +MessagePack.Formatters.CollectionFormatterBase +MessagePack.Formatters.CollectionFormatterBase.CollectionFormatterBase() -> void +MessagePack.Formatters.CollectionFormatterBase.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> TCollection? +MessagePack.Formatters.CollectionFormatterBase.Serialize(ref MessagePack.MessagePackWriter writer, TCollection? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ComplexFormatter +MessagePack.Formatters.ComplexFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Numerics.Complex +MessagePack.Formatters.ComplexFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Numerics.Complex value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ConcurrentBagFormatter +MessagePack.Formatters.ConcurrentBagFormatter.ConcurrentBagFormatter() -> void +MessagePack.Formatters.ConcurrentDictionaryFormatter +MessagePack.Formatters.ConcurrentDictionaryFormatter.ConcurrentDictionaryFormatter() -> void +MessagePack.Formatters.ConcurrentQueueFormatter +MessagePack.Formatters.ConcurrentQueueFormatter.ConcurrentQueueFormatter() -> void +MessagePack.Formatters.ConcurrentStackFormatter +MessagePack.Formatters.ConcurrentStackFormatter.ConcurrentStackFormatter() -> void +MessagePack.Formatters.DateTimeArrayFormatter +MessagePack.Formatters.DateTimeArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.DateTime[]? +MessagePack.Formatters.DateTimeArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.DateTime[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.DateTimeFormatter +MessagePack.Formatters.DateTimeFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.DateTime +MessagePack.Formatters.DateTimeFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.DateTime value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.DateTimeOffsetFormatter +MessagePack.Formatters.DateTimeOffsetFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.DateTimeOffset +MessagePack.Formatters.DateTimeOffsetFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.DateTimeOffset value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.DecimalFormatter +MessagePack.Formatters.DecimalFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> decimal +MessagePack.Formatters.DecimalFormatter.Serialize(ref MessagePack.MessagePackWriter writer, decimal value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.DictionaryFormatter +MessagePack.Formatters.DictionaryFormatter.DictionaryFormatter() -> void +MessagePack.Formatters.DictionaryFormatterBase +MessagePack.Formatters.DictionaryFormatterBase.DictionaryFormatterBase() -> void +MessagePack.Formatters.DictionaryFormatterBase +MessagePack.Formatters.DictionaryFormatterBase.DictionaryFormatterBase() -> void +MessagePack.Formatters.DictionaryFormatterBase +MessagePack.Formatters.DictionaryFormatterBase.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> TDictionary? +MessagePack.Formatters.DictionaryFormatterBase.DictionaryFormatterBase() -> void +MessagePack.Formatters.DictionaryFormatterBase.Serialize(ref MessagePack.MessagePackWriter writer, TDictionary? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.DoubleArrayFormatter +MessagePack.Formatters.DoubleArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> double[]? +MessagePack.Formatters.DoubleArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, double[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.DoubleFormatter +MessagePack.Formatters.DoubleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> double +MessagePack.Formatters.DoubleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, double value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.DynamicObjectTypeFallbackFormatter +MessagePack.Formatters.DynamicObjectTypeFallbackFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> object? +MessagePack.Formatters.DynamicObjectTypeFallbackFormatter.Serialize(ref MessagePack.MessagePackWriter writer, object? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.EnumAsStringFormatter +MessagePack.Formatters.EnumAsStringFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T +MessagePack.Formatters.EnumAsStringFormatter.EnumAsStringFormatter() -> void +MessagePack.Formatters.EnumAsStringFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceByteBlockFormatter +MessagePack.Formatters.ForceByteBlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> byte +MessagePack.Formatters.ForceByteBlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, byte value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceInt16BlockArrayFormatter +MessagePack.Formatters.ForceInt16BlockArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> short[]? +MessagePack.Formatters.ForceInt16BlockArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, short[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceInt16BlockFormatter +MessagePack.Formatters.ForceInt16BlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> short +MessagePack.Formatters.ForceInt16BlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, short value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceInt32BlockArrayFormatter +MessagePack.Formatters.ForceInt32BlockArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> int[]? +MessagePack.Formatters.ForceInt32BlockArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, int[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceInt32BlockFormatter +MessagePack.Formatters.ForceInt32BlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> int +MessagePack.Formatters.ForceInt32BlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, int value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceInt64BlockArrayFormatter +MessagePack.Formatters.ForceInt64BlockArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> long[]? +MessagePack.Formatters.ForceInt64BlockArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, long[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceInt64BlockFormatter +MessagePack.Formatters.ForceInt64BlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> long +MessagePack.Formatters.ForceInt64BlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, long value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceSByteBlockArrayFormatter +MessagePack.Formatters.ForceSByteBlockArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> sbyte[]? +MessagePack.Formatters.ForceSByteBlockArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, sbyte[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceSByteBlockFormatter +MessagePack.Formatters.ForceSByteBlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> sbyte +MessagePack.Formatters.ForceSByteBlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, sbyte value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceUInt16BlockArrayFormatter +MessagePack.Formatters.ForceUInt16BlockArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> ushort[]? +MessagePack.Formatters.ForceUInt16BlockArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, ushort[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceUInt16BlockFormatter +MessagePack.Formatters.ForceUInt16BlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> ushort +MessagePack.Formatters.ForceUInt16BlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, ushort value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceUInt32BlockArrayFormatter +MessagePack.Formatters.ForceUInt32BlockArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> uint[]? +MessagePack.Formatters.ForceUInt32BlockArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, uint[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceUInt32BlockFormatter +MessagePack.Formatters.ForceUInt32BlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> uint +MessagePack.Formatters.ForceUInt32BlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, uint value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceUInt64BlockArrayFormatter +MessagePack.Formatters.ForceUInt64BlockArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> ulong[]? +MessagePack.Formatters.ForceUInt64BlockArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, ulong[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceUInt64BlockFormatter +MessagePack.Formatters.ForceUInt64BlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> ulong +MessagePack.Formatters.ForceUInt64BlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, ulong value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.FourDimensionalArrayFormatter +MessagePack.Formatters.FourDimensionalArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T[,,,]? +MessagePack.Formatters.FourDimensionalArrayFormatter.FourDimensionalArrayFormatter() -> void +MessagePack.Formatters.FourDimensionalArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T[,,,]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.GenericCollectionFormatter +MessagePack.Formatters.GenericCollectionFormatter.GenericCollectionFormatter() -> void +MessagePack.Formatters.GenericDictionaryFormatter +MessagePack.Formatters.GenericDictionaryFormatter.GenericDictionaryFormatter() -> void +MessagePack.Formatters.GenericEnumFormatter +MessagePack.Formatters.GenericEnumFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T +MessagePack.Formatters.GenericEnumFormatter.GenericEnumFormatter() -> void +MessagePack.Formatters.GenericEnumFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.GuidFormatter +MessagePack.Formatters.GuidFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Guid +MessagePack.Formatters.GuidFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Guid value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.HashSetFormatter +MessagePack.Formatters.HashSetFormatter.HashSetFormatter() -> void +MessagePack.Formatters.IMessagePackFormatter +MessagePack.Formatters.IMessagePackFormatter +MessagePack.Formatters.IMessagePackFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T +MessagePack.Formatters.IMessagePackFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.IgnoreFormatter +MessagePack.Formatters.IgnoreFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T? +MessagePack.Formatters.IgnoreFormatter.IgnoreFormatter() -> void +MessagePack.Formatters.IgnoreFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.Int16ArrayFormatter +MessagePack.Formatters.Int16ArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> short[]? +MessagePack.Formatters.Int16ArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, short[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.Int16Formatter +MessagePack.Formatters.Int16Formatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> short +MessagePack.Formatters.Int16Formatter.Serialize(ref MessagePack.MessagePackWriter writer, short value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.Int32ArrayFormatter +MessagePack.Formatters.Int32ArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> int[]? +MessagePack.Formatters.Int32ArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, int[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.Int32Formatter +MessagePack.Formatters.Int32Formatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> int +MessagePack.Formatters.Int32Formatter.Serialize(ref MessagePack.MessagePackWriter writer, int value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.Int64ArrayFormatter +MessagePack.Formatters.Int64ArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> long[]? +MessagePack.Formatters.Int64ArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, long[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.Int64Formatter +MessagePack.Formatters.Int64Formatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> long +MessagePack.Formatters.Int64Formatter.Serialize(ref MessagePack.MessagePackWriter writer, long value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.InterfaceCollectionFormatter +MessagePack.Formatters.InterfaceCollectionFormatter.InterfaceCollectionFormatter() -> void +MessagePack.Formatters.InterfaceDictionaryFormatter +MessagePack.Formatters.InterfaceDictionaryFormatter.InterfaceDictionaryFormatter() -> void +MessagePack.Formatters.InterfaceEnumerableFormatter +MessagePack.Formatters.InterfaceEnumerableFormatter.InterfaceEnumerableFormatter() -> void +MessagePack.Formatters.InterfaceGroupingFormatter +MessagePack.Formatters.InterfaceGroupingFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Linq.IGrouping? +MessagePack.Formatters.InterfaceGroupingFormatter.InterfaceGroupingFormatter() -> void +MessagePack.Formatters.InterfaceGroupingFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Linq.IGrouping? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.InterfaceListFormatter +MessagePack.Formatters.InterfaceListFormatter.InterfaceListFormatter() -> void +MessagePack.Formatters.InterfaceLookupFormatter +MessagePack.Formatters.InterfaceLookupFormatter.InterfaceLookupFormatter() -> void +MessagePack.Formatters.InterfaceReadOnlyCollectionFormatter +MessagePack.Formatters.InterfaceReadOnlyCollectionFormatter.InterfaceReadOnlyCollectionFormatter() -> void +MessagePack.Formatters.InterfaceReadOnlyDictionaryFormatter +MessagePack.Formatters.InterfaceReadOnlyDictionaryFormatter.InterfaceReadOnlyDictionaryFormatter() -> void +MessagePack.Formatters.InterfaceReadOnlyListFormatter +MessagePack.Formatters.InterfaceReadOnlyListFormatter.InterfaceReadOnlyListFormatter() -> void +MessagePack.Formatters.InterfaceSetFormatter +MessagePack.Formatters.InterfaceSetFormatter.InterfaceSetFormatter() -> void +MessagePack.Formatters.KeyValuePairFormatter +MessagePack.Formatters.KeyValuePairFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Collections.Generic.KeyValuePair +MessagePack.Formatters.KeyValuePairFormatter.KeyValuePairFormatter() -> void +MessagePack.Formatters.KeyValuePairFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Collections.Generic.KeyValuePair value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.LazyFormatter +MessagePack.Formatters.LazyFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Lazy? +MessagePack.Formatters.LazyFormatter.LazyFormatter() -> void +MessagePack.Formatters.LazyFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Lazy? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.LinkedListFormatter +MessagePack.Formatters.LinkedListFormatter.LinkedListFormatter() -> void +MessagePack.Formatters.ListFormatter +MessagePack.Formatters.ListFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Collections.Generic.List? +MessagePack.Formatters.ListFormatter.ListFormatter() -> void +MessagePack.Formatters.ListFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Collections.Generic.List? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NativeDateTimeArrayFormatter +MessagePack.Formatters.NativeDateTimeArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.DateTime[]? +MessagePack.Formatters.NativeDateTimeArrayFormatter.NativeDateTimeArrayFormatter() -> void +MessagePack.Formatters.NativeDateTimeArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.DateTime[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NativeDateTimeFormatter +MessagePack.Formatters.NativeDateTimeFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.DateTime +MessagePack.Formatters.NativeDateTimeFormatter.NativeDateTimeFormatter() -> void +MessagePack.Formatters.NativeDateTimeFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.DateTime value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NativeDecimalFormatter +MessagePack.Formatters.NativeDecimalFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> decimal +MessagePack.Formatters.NativeDecimalFormatter.Serialize(ref MessagePack.MessagePackWriter writer, decimal value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NativeGuidFormatter +MessagePack.Formatters.NativeGuidFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Guid +MessagePack.Formatters.NativeGuidFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Guid value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NilFormatter +MessagePack.Formatters.NilFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> MessagePack.Nil +MessagePack.Formatters.NilFormatter.Serialize(ref MessagePack.MessagePackWriter writer, MessagePack.Nil value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NonGenericDictionaryFormatter +MessagePack.Formatters.NonGenericDictionaryFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T? +MessagePack.Formatters.NonGenericDictionaryFormatter.NonGenericDictionaryFormatter() -> void +MessagePack.Formatters.NonGenericDictionaryFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NonGenericInterfaceDictionaryFormatter +MessagePack.Formatters.NonGenericInterfaceDictionaryFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Collections.IDictionary? +MessagePack.Formatters.NonGenericInterfaceDictionaryFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Collections.IDictionary? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NonGenericInterfaceListFormatter +MessagePack.Formatters.NonGenericInterfaceListFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Collections.IList? +MessagePack.Formatters.NonGenericInterfaceListFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Collections.IList? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NonGenericListFormatter +MessagePack.Formatters.NonGenericListFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T? +MessagePack.Formatters.NonGenericListFormatter.NonGenericListFormatter() -> void +MessagePack.Formatters.NonGenericListFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableBooleanFormatter +MessagePack.Formatters.NullableBooleanFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> bool? +MessagePack.Formatters.NullableBooleanFormatter.Serialize(ref MessagePack.MessagePackWriter writer, bool? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableByteFormatter +MessagePack.Formatters.NullableByteFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> byte? +MessagePack.Formatters.NullableByteFormatter.Serialize(ref MessagePack.MessagePackWriter writer, byte? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableCharFormatter +MessagePack.Formatters.NullableCharFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> char? +MessagePack.Formatters.NullableCharFormatter.Serialize(ref MessagePack.MessagePackWriter writer, char? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableDateTimeFormatter +MessagePack.Formatters.NullableDateTimeFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.DateTime? +MessagePack.Formatters.NullableDateTimeFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.DateTime? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableDoubleFormatter +MessagePack.Formatters.NullableDoubleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> double? +MessagePack.Formatters.NullableDoubleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, double? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableForceByteBlockFormatter +MessagePack.Formatters.NullableForceByteBlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> byte? +MessagePack.Formatters.NullableForceByteBlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, byte? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableForceInt16BlockFormatter +MessagePack.Formatters.NullableForceInt16BlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> short? +MessagePack.Formatters.NullableForceInt16BlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, short? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableForceInt32BlockFormatter +MessagePack.Formatters.NullableForceInt32BlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> int? +MessagePack.Formatters.NullableForceInt32BlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, int? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableForceInt64BlockFormatter +MessagePack.Formatters.NullableForceInt64BlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> long? +MessagePack.Formatters.NullableForceInt64BlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, long? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableForceSByteBlockFormatter +MessagePack.Formatters.NullableForceSByteBlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> sbyte? +MessagePack.Formatters.NullableForceSByteBlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, sbyte? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableForceUInt16BlockFormatter +MessagePack.Formatters.NullableForceUInt16BlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> ushort? +MessagePack.Formatters.NullableForceUInt16BlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, ushort? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableForceUInt32BlockFormatter +MessagePack.Formatters.NullableForceUInt32BlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> uint? +MessagePack.Formatters.NullableForceUInt32BlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, uint? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableForceUInt64BlockFormatter +MessagePack.Formatters.NullableForceUInt64BlockFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> ulong? +MessagePack.Formatters.NullableForceUInt64BlockFormatter.Serialize(ref MessagePack.MessagePackWriter writer, ulong? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableFormatter +MessagePack.Formatters.NullableFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T? +MessagePack.Formatters.NullableFormatter.NullableFormatter() -> void +MessagePack.Formatters.NullableFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableInt16Formatter +MessagePack.Formatters.NullableInt16Formatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> short? +MessagePack.Formatters.NullableInt16Formatter.Serialize(ref MessagePack.MessagePackWriter writer, short? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableInt32Formatter +MessagePack.Formatters.NullableInt32Formatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> int? +MessagePack.Formatters.NullableInt32Formatter.Serialize(ref MessagePack.MessagePackWriter writer, int? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableInt64Formatter +MessagePack.Formatters.NullableInt64Formatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> long? +MessagePack.Formatters.NullableInt64Formatter.Serialize(ref MessagePack.MessagePackWriter writer, long? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableNilFormatter +MessagePack.Formatters.NullableNilFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> MessagePack.Nil? +MessagePack.Formatters.NullableNilFormatter.Serialize(ref MessagePack.MessagePackWriter writer, MessagePack.Nil? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableSByteFormatter +MessagePack.Formatters.NullableSByteFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> sbyte? +MessagePack.Formatters.NullableSByteFormatter.Serialize(ref MessagePack.MessagePackWriter writer, sbyte? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableSingleFormatter +MessagePack.Formatters.NullableSingleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> float? +MessagePack.Formatters.NullableSingleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, float? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableStringArrayFormatter +MessagePack.Formatters.NullableStringArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> string?[]? +MessagePack.Formatters.NullableStringArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, string?[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableStringFormatter +MessagePack.Formatters.NullableStringFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> string? +MessagePack.Formatters.NullableStringFormatter.Serialize(ref MessagePack.MessagePackWriter writer, string? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableUInt16Formatter +MessagePack.Formatters.NullableUInt16Formatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> ushort? +MessagePack.Formatters.NullableUInt16Formatter.Serialize(ref MessagePack.MessagePackWriter writer, ushort? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableUInt32Formatter +MessagePack.Formatters.NullableUInt32Formatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> uint? +MessagePack.Formatters.NullableUInt32Formatter.Serialize(ref MessagePack.MessagePackWriter writer, uint? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NullableUInt64Formatter +MessagePack.Formatters.NullableUInt64Formatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> ulong? +MessagePack.Formatters.NullableUInt64Formatter.Serialize(ref MessagePack.MessagePackWriter writer, ulong? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ObservableCollectionFormatter +MessagePack.Formatters.ObservableCollectionFormatter.ObservableCollectionFormatter() -> void +MessagePack.Formatters.PrimitiveObjectFormatter +MessagePack.Formatters.PrimitiveObjectFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> object? +MessagePack.Formatters.PrimitiveObjectFormatter.Serialize(ref MessagePack.MessagePackWriter writer, object? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.QueueFormatter +MessagePack.Formatters.QueueFormatter.QueueFormatter() -> void +MessagePack.Formatters.ReadOnlyCollectionFormatter +MessagePack.Formatters.ReadOnlyCollectionFormatter.ReadOnlyCollectionFormatter() -> void +MessagePack.Formatters.ReadOnlyDictionaryFormatter +MessagePack.Formatters.ReadOnlyDictionaryFormatter.ReadOnlyDictionaryFormatter() -> void +MessagePack.Formatters.ReadOnlyObservableCollectionFormatter +MessagePack.Formatters.ReadOnlyObservableCollectionFormatter.ReadOnlyObservableCollectionFormatter() -> void +MessagePack.Formatters.SByteArrayFormatter +MessagePack.Formatters.SByteArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> sbyte[]? +MessagePack.Formatters.SByteArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, sbyte[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.SByteFormatter +MessagePack.Formatters.SByteFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> sbyte +MessagePack.Formatters.SByteFormatter.Serialize(ref MessagePack.MessagePackWriter writer, sbyte value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.SingleArrayFormatter +MessagePack.Formatters.SingleArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> float[]? +MessagePack.Formatters.SingleArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, float[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.SingleFormatter +MessagePack.Formatters.SingleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> float +MessagePack.Formatters.SingleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, float value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.SortedDictionaryFormatter +MessagePack.Formatters.SortedDictionaryFormatter.SortedDictionaryFormatter() -> void +MessagePack.Formatters.SortedListFormatter +MessagePack.Formatters.SortedListFormatter.SortedListFormatter() -> void +MessagePack.Formatters.StackFormatter +MessagePack.Formatters.StackFormatter.StackFormatter() -> void +MessagePack.Formatters.StaticNullableFormatter +MessagePack.Formatters.StaticNullableFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T? +MessagePack.Formatters.StaticNullableFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.StaticNullableFormatter.StaticNullableFormatter(MessagePack.Formatters.IMessagePackFormatter! underlyingFormatter) -> void +MessagePack.Formatters.StringBuilderFormatter +MessagePack.Formatters.StringBuilderFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Text.StringBuilder? +MessagePack.Formatters.StringBuilderFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Text.StringBuilder? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ThreeDimensionalArrayFormatter +MessagePack.Formatters.ThreeDimensionalArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T[,,]? +MessagePack.Formatters.ThreeDimensionalArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T[,,]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ThreeDimensionalArrayFormatter.ThreeDimensionalArrayFormatter() -> void +MessagePack.Formatters.TimeSpanFormatter +MessagePack.Formatters.TimeSpanFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.TimeSpan +MessagePack.Formatters.TimeSpanFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.TimeSpan value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.TupleFormatter +MessagePack.Formatters.TupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Tuple? +MessagePack.Formatters.TupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Tuple? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.TupleFormatter.TupleFormatter() -> void +MessagePack.Formatters.TupleFormatter +MessagePack.Formatters.TupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Tuple? +MessagePack.Formatters.TupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Tuple? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.TupleFormatter.TupleFormatter() -> void +MessagePack.Formatters.TupleFormatter +MessagePack.Formatters.TupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Tuple? +MessagePack.Formatters.TupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Tuple? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.TupleFormatter.TupleFormatter() -> void +MessagePack.Formatters.TupleFormatter +MessagePack.Formatters.TupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Tuple? +MessagePack.Formatters.TupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Tuple? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.TupleFormatter.TupleFormatter() -> void +MessagePack.Formatters.TupleFormatter +MessagePack.Formatters.TupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Tuple? +MessagePack.Formatters.TupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Tuple? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.TupleFormatter.TupleFormatter() -> void +MessagePack.Formatters.TupleFormatter +MessagePack.Formatters.TupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Tuple? +MessagePack.Formatters.TupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Tuple? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.TupleFormatter.TupleFormatter() -> void +MessagePack.Formatters.TupleFormatter +MessagePack.Formatters.TupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Tuple? +MessagePack.Formatters.TupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Tuple? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.TupleFormatter.TupleFormatter() -> void +MessagePack.Formatters.TupleFormatter +MessagePack.Formatters.TupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Tuple? +MessagePack.Formatters.TupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Tuple? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.TupleFormatter.TupleFormatter() -> void +MessagePack.Formatters.TwoDimensionalArrayFormatter +MessagePack.Formatters.TwoDimensionalArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T[,]? +MessagePack.Formatters.TwoDimensionalArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T[,]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.TwoDimensionalArrayFormatter.TwoDimensionalArrayFormatter() -> void +MessagePack.Formatters.TypelessFormatter +MessagePack.Formatters.TypelessFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> object? +MessagePack.Formatters.TypelessFormatter.Serialize(ref MessagePack.MessagePackWriter writer, object? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.UInt16ArrayFormatter +MessagePack.Formatters.UInt16ArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> ushort[]? +MessagePack.Formatters.UInt16ArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, ushort[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.UInt16Formatter +MessagePack.Formatters.UInt16Formatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> ushort +MessagePack.Formatters.UInt16Formatter.Serialize(ref MessagePack.MessagePackWriter writer, ushort value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.UInt32ArrayFormatter +MessagePack.Formatters.UInt32ArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> uint[]? +MessagePack.Formatters.UInt32ArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, uint[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.UInt32Formatter +MessagePack.Formatters.UInt32Formatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> uint +MessagePack.Formatters.UInt32Formatter.Serialize(ref MessagePack.MessagePackWriter writer, uint value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.UInt64ArrayFormatter +MessagePack.Formatters.UInt64ArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> ulong[]? +MessagePack.Formatters.UInt64ArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, ulong[]? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.UInt64Formatter +MessagePack.Formatters.UInt64Formatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> ulong +MessagePack.Formatters.UInt64Formatter.Serialize(ref MessagePack.MessagePackWriter writer, ulong value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.UriFormatter +MessagePack.Formatters.UriFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Uri? +MessagePack.Formatters.UriFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Uri? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ValueTupleFormatter +MessagePack.Formatters.ValueTupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.ValueTuple +MessagePack.Formatters.ValueTupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.ValueTuple value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ValueTupleFormatter.ValueTupleFormatter() -> void +MessagePack.Formatters.ValueTupleFormatter +MessagePack.Formatters.ValueTupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> (T1, T2, T3, T4, T5, T6, T7) +MessagePack.Formatters.ValueTupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, (T1, T2, T3, T4, T5, T6, T7) value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ValueTupleFormatter.ValueTupleFormatter() -> void +MessagePack.Formatters.ValueTupleFormatter +MessagePack.Formatters.ValueTupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> (T1, T2, T3, T4, T5, T6) +MessagePack.Formatters.ValueTupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, (T1, T2, T3, T4, T5, T6) value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ValueTupleFormatter.ValueTupleFormatter() -> void +MessagePack.Formatters.ValueTupleFormatter +MessagePack.Formatters.ValueTupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> (T1, T2, T3, T4, T5) +MessagePack.Formatters.ValueTupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, (T1, T2, T3, T4, T5) value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ValueTupleFormatter.ValueTupleFormatter() -> void +MessagePack.Formatters.ValueTupleFormatter +MessagePack.Formatters.ValueTupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> (T1, T2, T3, T4) +MessagePack.Formatters.ValueTupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, (T1, T2, T3, T4) value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ValueTupleFormatter.ValueTupleFormatter() -> void +MessagePack.Formatters.ValueTupleFormatter +MessagePack.Formatters.ValueTupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> (T1, T2, T3) +MessagePack.Formatters.ValueTupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, (T1, T2, T3) value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ValueTupleFormatter.ValueTupleFormatter() -> void +MessagePack.Formatters.ValueTupleFormatter +MessagePack.Formatters.ValueTupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> (T1, T2) +MessagePack.Formatters.ValueTupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, (T1, T2) value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ValueTupleFormatter.ValueTupleFormatter() -> void +MessagePack.Formatters.ValueTupleFormatter +MessagePack.Formatters.ValueTupleFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.ValueTuple +MessagePack.Formatters.ValueTupleFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.ValueTuple value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ValueTupleFormatter.ValueTupleFormatter() -> void +MessagePack.Formatters.VersionFormatter +MessagePack.Formatters.VersionFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Version? +MessagePack.Formatters.VersionFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Version? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.IFormatterResolver +MessagePack.IFormatterResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Internal.AutomataDictionary +MessagePack.Internal.AutomataDictionary.Add(string! str, int value) -> void +MessagePack.Internal.AutomataDictionary.AutomataDictionary() -> void +MessagePack.Internal.AutomataDictionary.EmitMatch(System.Reflection.Emit.ILGenerator! il, System.Reflection.Emit.LocalBuilder! bytesSpan, System.Reflection.Emit.LocalBuilder! key, System.Action>! onFound, System.Action! onNotFound) -> void +MessagePack.Internal.AutomataDictionary.GetEnumerator() -> System.Collections.Generic.IEnumerator>! +MessagePack.Internal.AutomataDictionary.TryGetValue(System.ReadOnlySpan bytes, out int value) -> bool +MessagePack.Internal.AutomataDictionary.TryGetValue(in System.Buffers.ReadOnlySequence bytes, out int value) -> bool +MessagePack.Internal.AutomataKeyGen +MessagePack.Internal.ByteArrayStringHashTable +MessagePack.Internal.ByteArrayStringHashTable.Add(byte[]! key, int value) -> void +MessagePack.Internal.ByteArrayStringHashTable.Add(string! key, int value) -> void +MessagePack.Internal.ByteArrayStringHashTable.ByteArrayStringHashTable(int capacity) -> void +MessagePack.Internal.ByteArrayStringHashTable.ByteArrayStringHashTable(int capacity, float loadFactor) -> void +MessagePack.Internal.ByteArrayStringHashTable.GetEnumerator() -> System.Collections.Generic.IEnumerator>! +MessagePack.Internal.ByteArrayStringHashTable.TryGetValue(System.ReadOnlySpan key, out int value) -> bool +MessagePack.Internal.ByteArrayStringHashTable.TryGetValue(in System.Buffers.ReadOnlySequence key, out int value) -> bool +MessagePack.Internal.CodeGenHelpers +MessagePack.Internal.RuntimeTypeHandleEqualityComparer +MessagePack.Internal.RuntimeTypeHandleEqualityComparer.Equals(System.RuntimeTypeHandle x, System.RuntimeTypeHandle y) -> bool +MessagePack.Internal.RuntimeTypeHandleEqualityComparer.GetHashCode(System.RuntimeTypeHandle obj) -> int +MessagePack.Internal.UnsafeMemory +MessagePack.Internal.UnsafeMemory32 +MessagePack.Internal.UnsafeMemory64 +MessagePack.MessagePackCode +MessagePack.MessagePackCompression +MessagePack.MessagePackCompression.Lz4Block = 1 -> MessagePack.MessagePackCompression +MessagePack.MessagePackCompression.Lz4BlockArray = 2 -> MessagePack.MessagePackCompression +MessagePack.MessagePackCompression.None = 0 -> MessagePack.MessagePackCompression +MessagePack.MessagePackRange +MessagePack.MessagePackReader +MessagePack.MessagePackReader.CancellationToken.get -> System.Threading.CancellationToken +MessagePack.MessagePackReader.CancellationToken.set -> void +MessagePack.MessagePackReader.Clone(in System.Buffers.ReadOnlySequence readOnlySequence) -> MessagePack.MessagePackReader +MessagePack.MessagePackReader.Consumed.get -> long +MessagePack.MessagePackReader.CreatePeekReader() -> MessagePack.MessagePackReader +MessagePack.MessagePackReader.End.get -> bool +MessagePack.MessagePackReader.IsNil.get -> bool +MessagePack.MessagePackReader.MessagePackReader(System.ReadOnlyMemory memory) -> void +MessagePack.MessagePackReader.MessagePackReader(in System.Buffers.ReadOnlySequence readOnlySequence) -> void +MessagePack.MessagePackReader.NextCode.get -> byte +MessagePack.MessagePackReader.NextMessagePackType.get -> MessagePack.MessagePackType +MessagePack.MessagePackReader.Position.get -> System.SequencePosition +MessagePack.MessagePackReader.ReadArrayHeader() -> int +MessagePack.MessagePackReader.ReadBoolean() -> bool +MessagePack.MessagePackReader.ReadByte() -> byte +MessagePack.MessagePackReader.ReadBytes() -> System.Buffers.ReadOnlySequence? +MessagePack.MessagePackReader.ReadChar() -> char +MessagePack.MessagePackReader.ReadDateTime() -> System.DateTime +MessagePack.MessagePackReader.ReadDouble() -> double +MessagePack.MessagePackReader.ReadExtensionFormat() -> MessagePack.ExtensionResult +MessagePack.MessagePackReader.ReadExtensionFormatHeader() -> MessagePack.ExtensionHeader +MessagePack.MessagePackReader.ReadInt16() -> short +MessagePack.MessagePackReader.ReadInt32() -> int +MessagePack.MessagePackReader.ReadInt64() -> long +MessagePack.MessagePackReader.ReadMapHeader() -> int +MessagePack.MessagePackReader.ReadNil() -> MessagePack.Nil +MessagePack.MessagePackReader.ReadRaw() -> System.Buffers.ReadOnlySequence +MessagePack.MessagePackReader.ReadRaw(long length) -> System.Buffers.ReadOnlySequence +MessagePack.MessagePackReader.ReadSByte() -> sbyte +MessagePack.MessagePackReader.ReadSingle() -> float +MessagePack.MessagePackReader.ReadString() -> string? +MessagePack.MessagePackReader.ReadStringSequence() -> System.Buffers.ReadOnlySequence? +MessagePack.MessagePackReader.ReadUInt16() -> ushort +MessagePack.MessagePackReader.ReadUInt32() -> uint +MessagePack.MessagePackReader.ReadUInt64() -> ulong +MessagePack.MessagePackReader.Sequence.get -> System.Buffers.ReadOnlySequence +MessagePack.MessagePackReader.Skip() -> void +MessagePack.MessagePackReader.TryReadNil() -> bool +MessagePack.MessagePackReader.TryReadStringSpan(out System.ReadOnlySpan span) -> bool +MessagePack.MessagePackSerializationException +MessagePack.MessagePackSerializationException.MessagePackSerializationException() -> void +MessagePack.MessagePackSerializationException.MessagePackSerializationException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void +MessagePack.MessagePackSerializationException.MessagePackSerializationException(string? message) -> void +MessagePack.MessagePackSerializationException.MessagePackSerializationException(string? message, System.Exception? inner) -> void +MessagePack.MessagePackSerializer +MessagePack.MessagePackSerializer.Typeless +MessagePack.MessagePackSerializerOptions +MessagePack.MessagePackSerializerOptions.AllowAssemblyVersionMismatch.get -> bool +MessagePack.MessagePackSerializerOptions.Compression.get -> MessagePack.MessagePackCompression +MessagePack.MessagePackSerializerOptions.MessagePackSerializerOptions(MessagePack.IFormatterResolver! resolver) -> void +MessagePack.MessagePackSerializerOptions.MessagePackSerializerOptions(MessagePack.MessagePackSerializerOptions! copyFrom) -> void +MessagePack.MessagePackSerializerOptions.OldSpec.get -> bool? +MessagePack.MessagePackSerializerOptions.OmitAssemblyVersion.get -> bool +MessagePack.MessagePackSerializerOptions.Resolver.get -> MessagePack.IFormatterResolver! +MessagePack.MessagePackSerializerOptions.WithAllowAssemblyVersionMismatch(bool allowAssemblyVersionMismatch) -> MessagePack.MessagePackSerializerOptions! +MessagePack.MessagePackSerializerOptions.WithCompression(MessagePack.MessagePackCompression compression) -> MessagePack.MessagePackSerializerOptions! +MessagePack.MessagePackSerializerOptions.WithOldSpec(bool? oldSpec = true) -> MessagePack.MessagePackSerializerOptions! +MessagePack.MessagePackSerializerOptions.WithOmitAssemblyVersion(bool omitAssemblyVersion) -> MessagePack.MessagePackSerializerOptions! +MessagePack.MessagePackSerializerOptions.WithResolver(MessagePack.IFormatterResolver! resolver) -> MessagePack.MessagePackSerializerOptions! +MessagePack.MessagePackStreamReader +MessagePack.MessagePackStreamReader.Dispose() -> void +MessagePack.MessagePackStreamReader.MessagePackStreamReader(System.IO.Stream! stream) -> void +MessagePack.MessagePackStreamReader.ReadAsync(System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.ValueTask?> +MessagePack.MessagePackStreamReader.RemainingBytes.get -> System.Buffers.ReadOnlySequence +MessagePack.MessagePackType +MessagePack.MessagePackType.Array = 7 -> MessagePack.MessagePackType +MessagePack.MessagePackType.Binary = 6 -> MessagePack.MessagePackType +MessagePack.MessagePackType.Boolean = 3 -> MessagePack.MessagePackType +MessagePack.MessagePackType.Extension = 9 -> MessagePack.MessagePackType +MessagePack.MessagePackType.Float = 4 -> MessagePack.MessagePackType +MessagePack.MessagePackType.Integer = 1 -> MessagePack.MessagePackType +MessagePack.MessagePackType.Map = 8 -> MessagePack.MessagePackType +MessagePack.MessagePackType.Nil = 2 -> MessagePack.MessagePackType +MessagePack.MessagePackType.String = 5 -> MessagePack.MessagePackType +MessagePack.MessagePackType.Unknown = 0 -> MessagePack.MessagePackType +MessagePack.MessagePackWriter +MessagePack.MessagePackWriter.Advance(int length) -> void +MessagePack.MessagePackWriter.CancellationToken.get -> System.Threading.CancellationToken +MessagePack.MessagePackWriter.CancellationToken.set -> void +MessagePack.MessagePackWriter.Clone(System.Buffers.IBufferWriter! writer) -> MessagePack.MessagePackWriter +MessagePack.MessagePackWriter.Flush() -> void +MessagePack.MessagePackWriter.GetSpan(int length) -> System.Span +MessagePack.MessagePackWriter.MessagePackWriter(System.Buffers.IBufferWriter! writer) -> void +MessagePack.MessagePackWriter.OldSpec.get -> bool +MessagePack.MessagePackWriter.OldSpec.set -> void +MessagePack.MessagePackWriter.Write(System.DateTime dateTime) -> void +MessagePack.MessagePackWriter.Write(System.ReadOnlySpan src) -> void +MessagePack.MessagePackWriter.Write(System.ReadOnlySpan value) -> void +MessagePack.MessagePackWriter.Write(bool value) -> void +MessagePack.MessagePackWriter.Write(byte value) -> void +MessagePack.MessagePackWriter.Write(byte[]? src) -> void +MessagePack.MessagePackWriter.Write(char value) -> void +MessagePack.MessagePackWriter.Write(double value) -> void +MessagePack.MessagePackWriter.Write(float value) -> void +MessagePack.MessagePackWriter.Write(in System.Buffers.ReadOnlySequence src) -> void +MessagePack.MessagePackWriter.Write(int value) -> void +MessagePack.MessagePackWriter.Write(long value) -> void +MessagePack.MessagePackWriter.Write(sbyte value) -> void +MessagePack.MessagePackWriter.Write(short value) -> void +MessagePack.MessagePackWriter.Write(string? value) -> void +MessagePack.MessagePackWriter.Write(uint value) -> void +MessagePack.MessagePackWriter.Write(ulong value) -> void +MessagePack.MessagePackWriter.Write(ushort value) -> void +MessagePack.MessagePackWriter.WriteArrayHeader(int count) -> void +MessagePack.MessagePackWriter.WriteArrayHeader(uint count) -> void +MessagePack.MessagePackWriter.WriteExtensionFormat(MessagePack.ExtensionResult extensionData) -> void +MessagePack.MessagePackWriter.WriteExtensionFormatHeader(MessagePack.ExtensionHeader extensionHeader) -> void +MessagePack.MessagePackWriter.WriteInt16(short value) -> void +MessagePack.MessagePackWriter.WriteInt32(int value) -> void +MessagePack.MessagePackWriter.WriteInt64(long value) -> void +MessagePack.MessagePackWriter.WriteInt8(sbyte value) -> void +MessagePack.MessagePackWriter.WriteMapHeader(int count) -> void +MessagePack.MessagePackWriter.WriteMapHeader(uint count) -> void +MessagePack.MessagePackWriter.WriteNil() -> void +MessagePack.MessagePackWriter.WriteRaw(System.ReadOnlySpan rawMessagePackBlock) -> void +MessagePack.MessagePackWriter.WriteRaw(in System.Buffers.ReadOnlySequence rawMessagePackBlock) -> void +MessagePack.MessagePackWriter.WriteString(System.ReadOnlySpan utf8stringBytes) -> void +MessagePack.MessagePackWriter.WriteString(in System.Buffers.ReadOnlySequence utf8stringBytes) -> void +MessagePack.MessagePackWriter.WriteUInt16(ushort value) -> void +MessagePack.MessagePackWriter.WriteUInt32(uint value) -> void +MessagePack.MessagePackWriter.WriteUInt64(ulong value) -> void +MessagePack.MessagePackWriter.WriteUInt8(byte value) -> void +MessagePack.Nil +MessagePack.Nil.Equals(MessagePack.Nil other) -> bool +MessagePack.Nil.Nil() -> void +MessagePack.ReservedMessagePackExtensionTypeCode +MessagePack.Resolvers.AttributeFormatterResolver +MessagePack.Resolvers.AttributeFormatterResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.BuiltinResolver +MessagePack.Resolvers.BuiltinResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.CompositeResolver +MessagePack.Resolvers.ContractlessStandardResolver +MessagePack.Resolvers.ContractlessStandardResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.ContractlessStandardResolverAllowPrivate +MessagePack.Resolvers.ContractlessStandardResolverAllowPrivate.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.DynamicContractlessObjectResolver +MessagePack.Resolvers.DynamicContractlessObjectResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.DynamicContractlessObjectResolverAllowPrivate +MessagePack.Resolvers.DynamicContractlessObjectResolverAllowPrivate.DynamicContractlessObjectResolverAllowPrivate() -> void +MessagePack.Resolvers.DynamicContractlessObjectResolverAllowPrivate.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.DynamicEnumAsStringResolver +MessagePack.Resolvers.DynamicEnumAsStringResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.DynamicEnumResolver +MessagePack.Resolvers.DynamicEnumResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.DynamicGenericResolver +MessagePack.Resolvers.DynamicGenericResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.DynamicObjectResolver +MessagePack.Resolvers.DynamicObjectResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.DynamicObjectResolverAllowPrivate +MessagePack.Resolvers.DynamicObjectResolverAllowPrivate.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.DynamicUnionResolver +MessagePack.Resolvers.DynamicUnionResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.NativeDateTimeResolver +MessagePack.Resolvers.NativeDateTimeResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.NativeDecimalResolver +MessagePack.Resolvers.NativeDecimalResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.NativeGuidResolver +MessagePack.Resolvers.NativeGuidResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.PrimitiveObjectResolver +MessagePack.Resolvers.PrimitiveObjectResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.StandardResolver +MessagePack.Resolvers.StandardResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.StandardResolverAllowPrivate +MessagePack.Resolvers.StandardResolverAllowPrivate.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.StaticCompositeResolver +MessagePack.Resolvers.StaticCompositeResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.StaticCompositeResolver.Register(System.Collections.Generic.IReadOnlyList! formatters, System.Collections.Generic.IReadOnlyList! resolvers) -> void +MessagePack.Resolvers.StaticCompositeResolver.Register(params MessagePack.Formatters.IMessagePackFormatter![]! formatters) -> void +MessagePack.Resolvers.StaticCompositeResolver.Register(params MessagePack.IFormatterResolver![]! resolvers) -> void +MessagePack.Resolvers.TypelessContractlessStandardResolver +MessagePack.Resolvers.TypelessContractlessStandardResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.Resolvers.TypelessContractlessStandardResolver.TypelessContractlessStandardResolver() -> void +MessagePack.Resolvers.TypelessObjectResolver +MessagePack.Resolvers.TypelessObjectResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.TinyJsonException +MessagePack.TinyJsonException.TinyJsonException(string! message) -> void +abstract MessagePack.Formatters.CollectionFormatterBase.Add(TIntermediate collection, int index, TElement value, MessagePack.MessagePackSerializerOptions! options) -> void +abstract MessagePack.Formatters.CollectionFormatterBase.Complete(TIntermediate intermediateCollection) -> TCollection +abstract MessagePack.Formatters.CollectionFormatterBase.Create(int count, MessagePack.MessagePackSerializerOptions! options) -> TIntermediate +abstract MessagePack.Formatters.CollectionFormatterBase.GetSourceEnumerator(TCollection source) -> TEnumerator +abstract MessagePack.Formatters.DictionaryFormatterBase.Add(TIntermediate collection, int index, TKey key, TValue value, MessagePack.MessagePackSerializerOptions! options) -> void +abstract MessagePack.Formatters.DictionaryFormatterBase.Complete(TIntermediate intermediateCollection) -> TDictionary! +abstract MessagePack.Formatters.DictionaryFormatterBase.Create(int count, MessagePack.MessagePackSerializerOptions! options) -> TIntermediate +abstract MessagePack.Formatters.DictionaryFormatterBase.GetSourceEnumerator(TDictionary! source) -> TEnumerator +const MessagePack.MessagePackCode.Array16 = 220 -> byte +const MessagePack.MessagePackCode.Array32 = 221 -> byte +const MessagePack.MessagePackCode.Bin16 = 197 -> byte +const MessagePack.MessagePackCode.Bin32 = 198 -> byte +const MessagePack.MessagePackCode.Bin8 = 196 -> byte +const MessagePack.MessagePackCode.Ext16 = 200 -> byte +const MessagePack.MessagePackCode.Ext32 = 201 -> byte +const MessagePack.MessagePackCode.Ext8 = 199 -> byte +const MessagePack.MessagePackCode.False = 194 -> byte +const MessagePack.MessagePackCode.FixExt1 = 212 -> byte +const MessagePack.MessagePackCode.FixExt16 = 216 -> byte +const MessagePack.MessagePackCode.FixExt2 = 213 -> byte +const MessagePack.MessagePackCode.FixExt4 = 214 -> byte +const MessagePack.MessagePackCode.FixExt8 = 215 -> byte +const MessagePack.MessagePackCode.Float32 = 202 -> byte +const MessagePack.MessagePackCode.Float64 = 203 -> byte +const MessagePack.MessagePackCode.Int16 = 209 -> byte +const MessagePack.MessagePackCode.Int32 = 210 -> byte +const MessagePack.MessagePackCode.Int64 = 211 -> byte +const MessagePack.MessagePackCode.Int8 = 208 -> byte +const MessagePack.MessagePackCode.Map16 = 222 -> byte +const MessagePack.MessagePackCode.Map32 = 223 -> byte +const MessagePack.MessagePackCode.MaxFixArray = 159 -> byte +const MessagePack.MessagePackCode.MaxFixInt = 127 -> byte +const MessagePack.MessagePackCode.MaxFixMap = 143 -> byte +const MessagePack.MessagePackCode.MaxFixStr = 191 -> byte +const MessagePack.MessagePackCode.MaxNegativeFixInt = 255 -> byte +const MessagePack.MessagePackCode.MinFixArray = 144 -> byte +const MessagePack.MessagePackCode.MinFixInt = 0 -> byte +const MessagePack.MessagePackCode.MinFixMap = 128 -> byte +const MessagePack.MessagePackCode.MinFixStr = 160 -> byte +const MessagePack.MessagePackCode.MinNegativeFixInt = 224 -> byte +const MessagePack.MessagePackCode.NeverUsed = 193 -> byte +const MessagePack.MessagePackCode.Nil = 192 -> byte +const MessagePack.MessagePackCode.Str16 = 218 -> byte +const MessagePack.MessagePackCode.Str32 = 219 -> byte +const MessagePack.MessagePackCode.Str8 = 217 -> byte +const MessagePack.MessagePackCode.True = 195 -> byte +const MessagePack.MessagePackCode.UInt16 = 205 -> byte +const MessagePack.MessagePackCode.UInt32 = 206 -> byte +const MessagePack.MessagePackCode.UInt64 = 207 -> byte +const MessagePack.MessagePackCode.UInt8 = 204 -> byte +const MessagePack.MessagePackRange.MaxFixArrayCount = 15 -> int +const MessagePack.MessagePackRange.MaxFixMapCount = 15 -> int +const MessagePack.MessagePackRange.MaxFixNegativeInt = -1 -> int +const MessagePack.MessagePackRange.MaxFixPositiveInt = 127 -> int +const MessagePack.MessagePackRange.MaxFixStringLength = 31 -> int +const MessagePack.MessagePackRange.MinFixNegativeInt = -32 -> int +const MessagePack.MessagePackRange.MinFixStringLength = 0 -> int +const MessagePack.ReservedMessagePackExtensionTypeCode.DateTime = -1 -> sbyte +override MessagePack.Formatters.CollectionFormatterBase.GetSourceEnumerator(TCollection source) -> System.Collections.Generic.IEnumerator! +override MessagePack.Formatters.DictionaryFormatterBase.Complete(TDictionary! intermediateCollection) -> TDictionary! +override MessagePack.Formatters.DictionaryFormatterBase.GetSourceEnumerator(TDictionary! source) -> System.Collections.Generic.IEnumerator>! +override MessagePack.Internal.AutomataDictionary.ToString() -> string! +override MessagePack.Nil.Equals(object? obj) -> bool +override MessagePack.Nil.GetHashCode() -> int +override MessagePack.Nil.ToString() -> string! +override sealed MessagePack.Formatters.CollectionFormatterBase.Complete(TCollection intermediateCollection) -> TCollection +static MessagePack.FormatterResolverExtensions.GetFormatterDynamic(this MessagePack.IFormatterResolver! resolver, System.Type! type) -> object? +static MessagePack.FormatterResolverExtensions.GetFormatterWithVerify(this MessagePack.IFormatterResolver! resolver) -> MessagePack.Formatters.IMessagePackFormatter! +static MessagePack.Formatters.PrimitiveObjectFormatter.IsSupportedType(System.Type! type, System.Reflection.TypeInfo! typeInfo, object! value) -> bool +static MessagePack.Internal.AutomataKeyGen.GetKey(ref System.ReadOnlySpan span) -> ulong +static MessagePack.Internal.CodeGenHelpers.GetArrayFromNullableSequence(in System.Buffers.ReadOnlySequence? sequence) -> byte[]? +static MessagePack.Internal.CodeGenHelpers.GetEncodedStringBytes(string! value) -> byte[]! +static MessagePack.Internal.CodeGenHelpers.GetSpanFromSequence(in System.Buffers.ReadOnlySequence sequence) -> System.ReadOnlySpan +static MessagePack.Internal.CodeGenHelpers.ReadStringSpan(ref MessagePack.MessagePackReader reader) -> System.ReadOnlySpan +static MessagePack.Internal.UnsafeMemory32.WriteRaw1(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw10(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw11(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw12(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw13(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw14(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw15(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw16(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw17(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw18(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw19(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw2(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw20(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw21(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw22(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw23(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw24(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw25(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw26(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw27(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw28(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw29(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw3(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw30(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw31(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw4(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw5(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw6(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw7(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw8(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory32.WriteRaw9(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw1(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw10(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw11(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw12(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw13(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw14(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw15(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw16(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw17(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw18(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw19(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw2(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw20(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw21(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw22(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw23(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw24(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw25(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw26(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw27(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw28(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw29(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw3(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw30(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw31(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw4(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw5(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw6(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw7(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw8(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.Internal.UnsafeMemory64.WriteRaw9(ref MessagePack.MessagePackWriter writer, System.ReadOnlySpan src) -> void +static MessagePack.MessagePackCode.ToFormatName(byte code) -> string! +static MessagePack.MessagePackCode.ToMessagePackType(byte code) -> MessagePack.MessagePackType +static MessagePack.MessagePackSerializer.ConvertFromJson(System.IO.TextReader! reader, ref MessagePack.MessagePackWriter writer, MessagePack.MessagePackSerializerOptions? options = null) -> void +static MessagePack.MessagePackSerializer.ConvertFromJson(string! str, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> byte[]! +static MessagePack.MessagePackSerializer.ConvertFromJson(string! str, ref MessagePack.MessagePackWriter writer, MessagePack.MessagePackSerializerOptions? options = null) -> void +static MessagePack.MessagePackSerializer.ConvertToJson(System.ReadOnlyMemory bytes, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> string! +static MessagePack.MessagePackSerializer.ConvertToJson(in System.Buffers.ReadOnlySequence bytes, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> string! +static MessagePack.MessagePackSerializer.ConvertToJson(ref MessagePack.MessagePackReader reader, System.IO.TextWriter! jsonWriter, MessagePack.MessagePackSerializerOptions? options = null) -> void +static MessagePack.MessagePackSerializer.DefaultOptions.get -> MessagePack.MessagePackSerializerOptions! +static MessagePack.MessagePackSerializer.DefaultOptions.set -> void +static MessagePack.MessagePackSerializer.Deserialize(System.Type! type, System.Buffers.ReadOnlySequence bytes, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> object? +static MessagePack.MessagePackSerializer.Deserialize(System.Type! type, System.IO.Stream! stream, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> object? +static MessagePack.MessagePackSerializer.Deserialize(System.Type! type, System.ReadOnlyMemory bytes, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> object? +static MessagePack.MessagePackSerializer.Deserialize(System.Type! type, ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions? options = null) -> object? +static MessagePack.MessagePackSerializer.Deserialize(System.IO.Stream! stream, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> T +static MessagePack.MessagePackSerializer.Deserialize(System.ReadOnlyMemory buffer, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> T +static MessagePack.MessagePackSerializer.Deserialize(System.ReadOnlyMemory buffer, MessagePack.MessagePackSerializerOptions? options, out int bytesRead, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> T +static MessagePack.MessagePackSerializer.Deserialize(System.ReadOnlyMemory buffer, out int bytesRead, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> T +static MessagePack.MessagePackSerializer.Deserialize(in System.Buffers.ReadOnlySequence byteSequence, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> T +static MessagePack.MessagePackSerializer.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions? options = null) -> T +static MessagePack.MessagePackSerializer.DeserializeAsync(System.Type! type, System.IO.Stream! stream, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +static MessagePack.MessagePackSerializer.DeserializeAsync(System.IO.Stream! stream, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +static MessagePack.MessagePackSerializer.Serialize(System.Type! type, System.Buffers.IBufferWriter! writer, object? obj, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> void +static MessagePack.MessagePackSerializer.Serialize(System.Type! type, System.IO.Stream! stream, object? obj, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> void +static MessagePack.MessagePackSerializer.Serialize(System.Type! type, object? obj, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> byte[]! +static MessagePack.MessagePackSerializer.Serialize(System.Type! type, ref MessagePack.MessagePackWriter writer, object? obj, MessagePack.MessagePackSerializerOptions? options = null) -> void +static MessagePack.MessagePackSerializer.Serialize(System.Buffers.IBufferWriter! writer, T value, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> void +static MessagePack.MessagePackSerializer.Serialize(System.IO.Stream! stream, T value, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> void +static MessagePack.MessagePackSerializer.Serialize(T value, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> byte[]! +static MessagePack.MessagePackSerializer.Serialize(ref MessagePack.MessagePackWriter writer, T value, MessagePack.MessagePackSerializerOptions? options = null) -> void +static MessagePack.MessagePackSerializer.SerializeAsync(System.Type! type, System.IO.Stream! stream, object? obj, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! +static MessagePack.MessagePackSerializer.SerializeAsync(System.IO.Stream! stream, T value, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! +static MessagePack.MessagePackSerializer.SerializeToJson(System.IO.TextWriter! textWriter, T obj, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> void +static MessagePack.MessagePackSerializer.SerializeToJson(T obj, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> string! +static MessagePack.MessagePackSerializer.Typeless.DefaultOptions.get -> MessagePack.MessagePackSerializerOptions! +static MessagePack.MessagePackSerializer.Typeless.DefaultOptions.set -> void +static MessagePack.MessagePackSerializer.Typeless.Deserialize(System.IO.Stream! stream, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> object? +static MessagePack.MessagePackSerializer.Typeless.Deserialize(System.Memory bytes, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> object? +static MessagePack.MessagePackSerializer.Typeless.Deserialize(in System.Buffers.ReadOnlySequence byteSequence, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> object? +static MessagePack.MessagePackSerializer.Typeless.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions? options = null) -> object? +static MessagePack.MessagePackSerializer.Typeless.DeserializeAsync(System.IO.Stream! stream, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.ValueTask +static MessagePack.MessagePackSerializer.Typeless.Serialize(System.Buffers.IBufferWriter! writer, object? obj, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> void +static MessagePack.MessagePackSerializer.Typeless.Serialize(System.IO.Stream! stream, object? obj, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> void +static MessagePack.MessagePackSerializer.Typeless.Serialize(object? obj, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> byte[]! +static MessagePack.MessagePackSerializer.Typeless.Serialize(ref MessagePack.MessagePackWriter writer, object? obj, MessagePack.MessagePackSerializerOptions? options = null) -> void +static MessagePack.MessagePackSerializer.Typeless.SerializeAsync(System.IO.Stream! stream, object? obj, MessagePack.MessagePackSerializerOptions? options = null, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Threading.Tasks.Task! +static MessagePack.MessagePackSerializerOptions.Standard.get -> MessagePack.MessagePackSerializerOptions! +static MessagePack.Resolvers.CompositeResolver.Create(System.Collections.Generic.IReadOnlyList! formatters, System.Collections.Generic.IReadOnlyList! resolvers) -> MessagePack.IFormatterResolver! +static MessagePack.Resolvers.CompositeResolver.Create(params MessagePack.Formatters.IMessagePackFormatter![]! formatters) -> MessagePack.IFormatterResolver! +static MessagePack.Resolvers.CompositeResolver.Create(params MessagePack.IFormatterResolver![]! resolvers) -> MessagePack.IFormatterResolver! +static readonly MessagePack.Formatters.BigIntegerFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.BitArrayFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.BooleanArrayFormatter.Instance -> MessagePack.Formatters.BooleanArrayFormatter! +static readonly MessagePack.Formatters.BooleanFormatter.Instance -> MessagePack.Formatters.BooleanFormatter! +static readonly MessagePack.Formatters.ByteArrayFormatter.Instance -> MessagePack.Formatters.ByteArrayFormatter! +static readonly MessagePack.Formatters.ByteArraySegmentFormatter.Instance -> MessagePack.Formatters.ByteArraySegmentFormatter! +static readonly MessagePack.Formatters.ByteFormatter.Instance -> MessagePack.Formatters.ByteFormatter! +static readonly MessagePack.Formatters.CharArrayFormatter.Instance -> MessagePack.Formatters.CharArrayFormatter! +static readonly MessagePack.Formatters.CharFormatter.Instance -> MessagePack.Formatters.CharFormatter! +static readonly MessagePack.Formatters.ComplexFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.DateTimeArrayFormatter.Instance -> MessagePack.Formatters.DateTimeArrayFormatter! +static readonly MessagePack.Formatters.DateTimeFormatter.Instance -> MessagePack.Formatters.DateTimeFormatter! +static readonly MessagePack.Formatters.DateTimeOffsetFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.DecimalFormatter.Instance -> MessagePack.Formatters.DecimalFormatter! +static readonly MessagePack.Formatters.DoubleArrayFormatter.Instance -> MessagePack.Formatters.DoubleArrayFormatter! +static readonly MessagePack.Formatters.DoubleFormatter.Instance -> MessagePack.Formatters.DoubleFormatter! +static readonly MessagePack.Formatters.DynamicObjectTypeFallbackFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.ForceByteBlockFormatter.Instance -> MessagePack.Formatters.ForceByteBlockFormatter! +static readonly MessagePack.Formatters.ForceInt16BlockArrayFormatter.Instance -> MessagePack.Formatters.ForceInt16BlockArrayFormatter! +static readonly MessagePack.Formatters.ForceInt16BlockFormatter.Instance -> MessagePack.Formatters.ForceInt16BlockFormatter! +static readonly MessagePack.Formatters.ForceInt32BlockArrayFormatter.Instance -> MessagePack.Formatters.ForceInt32BlockArrayFormatter! +static readonly MessagePack.Formatters.ForceInt32BlockFormatter.Instance -> MessagePack.Formatters.ForceInt32BlockFormatter! +static readonly MessagePack.Formatters.ForceInt64BlockArrayFormatter.Instance -> MessagePack.Formatters.ForceInt64BlockArrayFormatter! +static readonly MessagePack.Formatters.ForceInt64BlockFormatter.Instance -> MessagePack.Formatters.ForceInt64BlockFormatter! +static readonly MessagePack.Formatters.ForceSByteBlockArrayFormatter.Instance -> MessagePack.Formatters.ForceSByteBlockArrayFormatter! +static readonly MessagePack.Formatters.ForceSByteBlockFormatter.Instance -> MessagePack.Formatters.ForceSByteBlockFormatter! +static readonly MessagePack.Formatters.ForceUInt16BlockArrayFormatter.Instance -> MessagePack.Formatters.ForceUInt16BlockArrayFormatter! +static readonly MessagePack.Formatters.ForceUInt16BlockFormatter.Instance -> MessagePack.Formatters.ForceUInt16BlockFormatter! +static readonly MessagePack.Formatters.ForceUInt32BlockArrayFormatter.Instance -> MessagePack.Formatters.ForceUInt32BlockArrayFormatter! +static readonly MessagePack.Formatters.ForceUInt32BlockFormatter.Instance -> MessagePack.Formatters.ForceUInt32BlockFormatter! +static readonly MessagePack.Formatters.ForceUInt64BlockArrayFormatter.Instance -> MessagePack.Formatters.ForceUInt64BlockArrayFormatter! +static readonly MessagePack.Formatters.ForceUInt64BlockFormatter.Instance -> MessagePack.Formatters.ForceUInt64BlockFormatter! +static readonly MessagePack.Formatters.GuidFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.Int16ArrayFormatter.Instance -> MessagePack.Formatters.Int16ArrayFormatter! +static readonly MessagePack.Formatters.Int16Formatter.Instance -> MessagePack.Formatters.Int16Formatter! +static readonly MessagePack.Formatters.Int32ArrayFormatter.Instance -> MessagePack.Formatters.Int32ArrayFormatter! +static readonly MessagePack.Formatters.Int32Formatter.Instance -> MessagePack.Formatters.Int32Formatter! +static readonly MessagePack.Formatters.Int64ArrayFormatter.Instance -> MessagePack.Formatters.Int64ArrayFormatter! +static readonly MessagePack.Formatters.Int64Formatter.Instance -> MessagePack.Formatters.Int64Formatter! +static readonly MessagePack.Formatters.NativeDateTimeArrayFormatter.Instance -> MessagePack.Formatters.NativeDateTimeArrayFormatter! +static readonly MessagePack.Formatters.NativeDateTimeFormatter.Instance -> MessagePack.Formatters.NativeDateTimeFormatter! +static readonly MessagePack.Formatters.NativeDecimalFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.NativeGuidFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.NilFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.NonGenericInterfaceDictionaryFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.NonGenericInterfaceListFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.NullableBooleanFormatter.Instance -> MessagePack.Formatters.NullableBooleanFormatter! +static readonly MessagePack.Formatters.NullableByteFormatter.Instance -> MessagePack.Formatters.NullableByteFormatter! +static readonly MessagePack.Formatters.NullableCharFormatter.Instance -> MessagePack.Formatters.NullableCharFormatter! +static readonly MessagePack.Formatters.NullableDateTimeFormatter.Instance -> MessagePack.Formatters.NullableDateTimeFormatter! +static readonly MessagePack.Formatters.NullableDoubleFormatter.Instance -> MessagePack.Formatters.NullableDoubleFormatter! +static readonly MessagePack.Formatters.NullableForceByteBlockFormatter.Instance -> MessagePack.Formatters.NullableForceByteBlockFormatter! +static readonly MessagePack.Formatters.NullableForceInt16BlockFormatter.Instance -> MessagePack.Formatters.NullableForceInt16BlockFormatter! +static readonly MessagePack.Formatters.NullableForceInt32BlockFormatter.Instance -> MessagePack.Formatters.NullableForceInt32BlockFormatter! +static readonly MessagePack.Formatters.NullableForceInt64BlockFormatter.Instance -> MessagePack.Formatters.NullableForceInt64BlockFormatter! +static readonly MessagePack.Formatters.NullableForceSByteBlockFormatter.Instance -> MessagePack.Formatters.NullableForceSByteBlockFormatter! +static readonly MessagePack.Formatters.NullableForceUInt16BlockFormatter.Instance -> MessagePack.Formatters.NullableForceUInt16BlockFormatter! +static readonly MessagePack.Formatters.NullableForceUInt32BlockFormatter.Instance -> MessagePack.Formatters.NullableForceUInt32BlockFormatter! +static readonly MessagePack.Formatters.NullableForceUInt64BlockFormatter.Instance -> MessagePack.Formatters.NullableForceUInt64BlockFormatter! +static readonly MessagePack.Formatters.NullableInt16Formatter.Instance -> MessagePack.Formatters.NullableInt16Formatter! +static readonly MessagePack.Formatters.NullableInt32Formatter.Instance -> MessagePack.Formatters.NullableInt32Formatter! +static readonly MessagePack.Formatters.NullableInt64Formatter.Instance -> MessagePack.Formatters.NullableInt64Formatter! +static readonly MessagePack.Formatters.NullableNilFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.NullableSByteFormatter.Instance -> MessagePack.Formatters.NullableSByteFormatter! +static readonly MessagePack.Formatters.NullableSingleFormatter.Instance -> MessagePack.Formatters.NullableSingleFormatter! +static readonly MessagePack.Formatters.NullableStringArrayFormatter.Instance -> MessagePack.Formatters.NullableStringArrayFormatter! +static readonly MessagePack.Formatters.NullableStringFormatter.Instance -> MessagePack.Formatters.NullableStringFormatter! +static readonly MessagePack.Formatters.NullableUInt16Formatter.Instance -> MessagePack.Formatters.NullableUInt16Formatter! +static readonly MessagePack.Formatters.NullableUInt32Formatter.Instance -> MessagePack.Formatters.NullableUInt32Formatter! +static readonly MessagePack.Formatters.NullableUInt64Formatter.Instance -> MessagePack.Formatters.NullableUInt64Formatter! +static readonly MessagePack.Formatters.PrimitiveObjectFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.SByteArrayFormatter.Instance -> MessagePack.Formatters.SByteArrayFormatter! +static readonly MessagePack.Formatters.SByteFormatter.Instance -> MessagePack.Formatters.SByteFormatter! +static readonly MessagePack.Formatters.SingleArrayFormatter.Instance -> MessagePack.Formatters.SingleArrayFormatter! +static readonly MessagePack.Formatters.SingleFormatter.Instance -> MessagePack.Formatters.SingleFormatter! +static readonly MessagePack.Formatters.StringBuilderFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.TimeSpanFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.TypelessFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.UInt16ArrayFormatter.Instance -> MessagePack.Formatters.UInt16ArrayFormatter! +static readonly MessagePack.Formatters.UInt16Formatter.Instance -> MessagePack.Formatters.UInt16Formatter! +static readonly MessagePack.Formatters.UInt32ArrayFormatter.Instance -> MessagePack.Formatters.UInt32ArrayFormatter! +static readonly MessagePack.Formatters.UInt32Formatter.Instance -> MessagePack.Formatters.UInt32Formatter! +static readonly MessagePack.Formatters.UInt64ArrayFormatter.Instance -> MessagePack.Formatters.UInt64ArrayFormatter! +static readonly MessagePack.Formatters.UInt64Formatter.Instance -> MessagePack.Formatters.UInt64Formatter! +static readonly MessagePack.Formatters.UriFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.VersionFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Internal.AutomataKeyGen.GetKeyMethod -> System.Reflection.MethodInfo! +static readonly MessagePack.Internal.RuntimeTypeHandleEqualityComparer.Default -> System.Collections.Generic.IEqualityComparer! +static readonly MessagePack.Internal.UnsafeMemory.Is32Bit -> bool +static readonly MessagePack.Nil.Default -> MessagePack.Nil +static readonly MessagePack.Resolvers.AttributeFormatterResolver.Instance -> MessagePack.Resolvers.AttributeFormatterResolver! +static readonly MessagePack.Resolvers.BuiltinResolver.Instance -> MessagePack.Resolvers.BuiltinResolver! +static readonly MessagePack.Resolvers.ContractlessStandardResolver.Instance -> MessagePack.Resolvers.ContractlessStandardResolver! +static readonly MessagePack.Resolvers.ContractlessStandardResolver.Options -> MessagePack.MessagePackSerializerOptions! +static readonly MessagePack.Resolvers.ContractlessStandardResolverAllowPrivate.Instance -> MessagePack.Resolvers.ContractlessStandardResolverAllowPrivate! +static readonly MessagePack.Resolvers.ContractlessStandardResolverAllowPrivate.Options -> MessagePack.MessagePackSerializerOptions! +static readonly MessagePack.Resolvers.DynamicContractlessObjectResolver.Instance -> MessagePack.Resolvers.DynamicContractlessObjectResolver! +static readonly MessagePack.Resolvers.DynamicContractlessObjectResolverAllowPrivate.Instance -> MessagePack.Resolvers.DynamicContractlessObjectResolverAllowPrivate! +static readonly MessagePack.Resolvers.DynamicEnumAsStringResolver.Instance -> MessagePack.Resolvers.DynamicEnumAsStringResolver! +static readonly MessagePack.Resolvers.DynamicEnumAsStringResolver.Options -> MessagePack.MessagePackSerializerOptions! +static readonly MessagePack.Resolvers.DynamicEnumResolver.Instance -> MessagePack.Resolvers.DynamicEnumResolver! +static readonly MessagePack.Resolvers.DynamicGenericResolver.Instance -> MessagePack.Resolvers.DynamicGenericResolver! +static readonly MessagePack.Resolvers.DynamicObjectResolver.Instance -> MessagePack.Resolvers.DynamicObjectResolver! +static readonly MessagePack.Resolvers.DynamicObjectResolver.Options -> MessagePack.MessagePackSerializerOptions! +static readonly MessagePack.Resolvers.DynamicObjectResolverAllowPrivate.Instance -> MessagePack.Resolvers.DynamicObjectResolverAllowPrivate! +static readonly MessagePack.Resolvers.DynamicUnionResolver.Instance -> MessagePack.Resolvers.DynamicUnionResolver! +static readonly MessagePack.Resolvers.DynamicUnionResolver.Options -> MessagePack.MessagePackSerializerOptions! +static readonly MessagePack.Resolvers.NativeDateTimeResolver.Instance -> MessagePack.Resolvers.NativeDateTimeResolver! +static readonly MessagePack.Resolvers.NativeDateTimeResolver.Options -> MessagePack.MessagePackSerializerOptions! +static readonly MessagePack.Resolvers.NativeDecimalResolver.Instance -> MessagePack.Resolvers.NativeDecimalResolver! +static readonly MessagePack.Resolvers.NativeGuidResolver.Instance -> MessagePack.Resolvers.NativeGuidResolver! +static readonly MessagePack.Resolvers.PrimitiveObjectResolver.Instance -> MessagePack.Resolvers.PrimitiveObjectResolver! +static readonly MessagePack.Resolvers.PrimitiveObjectResolver.Options -> MessagePack.MessagePackSerializerOptions! +static readonly MessagePack.Resolvers.StandardResolver.Instance -> MessagePack.Resolvers.StandardResolver! +static readonly MessagePack.Resolvers.StandardResolver.Options -> MessagePack.MessagePackSerializerOptions! +static readonly MessagePack.Resolvers.StandardResolverAllowPrivate.Instance -> MessagePack.Resolvers.StandardResolverAllowPrivate! +static readonly MessagePack.Resolvers.StandardResolverAllowPrivate.Options -> MessagePack.MessagePackSerializerOptions! +static readonly MessagePack.Resolvers.StaticCompositeResolver.Instance -> MessagePack.Resolvers.StaticCompositeResolver! +static readonly MessagePack.Resolvers.TypelessContractlessStandardResolver.Instance -> MessagePack.Resolvers.TypelessContractlessStandardResolver! +static readonly MessagePack.Resolvers.TypelessContractlessStandardResolver.Options -> MessagePack.MessagePackSerializerOptions! +static readonly MessagePack.Resolvers.TypelessObjectResolver.Instance -> MessagePack.IFormatterResolver! +virtual MessagePack.Formatters.CollectionFormatterBase.GetCount(TCollection sequence) -> int? +virtual MessagePack.MessagePackSerializerOptions.Clone() -> MessagePack.MessagePackSerializerOptions! +virtual MessagePack.MessagePackSerializerOptions.LoadType(string! typeName) -> System.Type? +virtual MessagePack.MessagePackSerializerOptions.ThrowIfDeserializingTypeIsDisallowed(System.Type! type) -> void +MessagePack.ExtensionHeader.Equals(MessagePack.ExtensionHeader other) -> bool +MessagePack.Formatters.InterfaceCollectionFormatter2 +MessagePack.Formatters.InterfaceCollectionFormatter2.InterfaceCollectionFormatter2() -> void +MessagePack.Formatters.InterfaceListFormatter2 +MessagePack.Formatters.InterfaceListFormatter2.InterfaceListFormatter2() -> void +MessagePack.MessagePackReader.Depth.get -> int +MessagePack.MessagePackReader.Depth.set -> void +MessagePack.MessagePackReader.ReadDateTime(MessagePack.ExtensionHeader header) -> System.DateTime +MessagePack.MessagePackReader.TryReadArrayHeader(out int count) -> bool +MessagePack.MessagePackReader.TryReadExtensionFormatHeader(out MessagePack.ExtensionHeader extensionHeader) -> bool +MessagePack.MessagePackReader.TryReadMapHeader(out int count) -> bool +MessagePack.MessagePackSecurity +MessagePack.MessagePackSecurity.DepthStep(ref MessagePack.MessagePackReader reader) -> void +MessagePack.MessagePackSecurity.GetEqualityComparer() -> System.Collections.IEqualityComparer! +MessagePack.MessagePackSecurity.GetEqualityComparer() -> System.Collections.Generic.IEqualityComparer! +MessagePack.MessagePackSecurity.HashCollisionResistant.get -> bool +MessagePack.MessagePackSecurity.MaximumObjectGraphDepth.get -> int +MessagePack.MessagePackSecurity.MessagePackSecurity(MessagePack.MessagePackSecurity! copyFrom) -> void +MessagePack.MessagePackSecurity.WithHashCollisionResistant(bool hashCollisionResistant) -> MessagePack.MessagePackSecurity! +MessagePack.MessagePackSecurity.WithMaximumObjectGraphDepth(int maximumObjectGraphDepth) -> MessagePack.MessagePackSecurity! +MessagePack.MessagePackSerializerOptions.Security.get -> MessagePack.MessagePackSecurity! +MessagePack.MessagePackSerializerOptions.WithSecurity(MessagePack.MessagePackSecurity! security) -> MessagePack.MessagePackSerializerOptions! +MessagePack.MessagePackStreamReader.DiscardBufferedData() -> void +MessagePack.MessagePackStreamReader.MessagePackStreamReader(System.IO.Stream! stream, bool leaveOpen) -> void +MessagePack.MessagePackStreamReader.ReadArrayAsync(System.Threading.CancellationToken cancellationToken) -> System.Collections.Generic.IAsyncEnumerable>! +MessagePack.MessagePackWriter.WriteBinHeader(int length) -> void +MessagePack.MessagePackWriter.WriteStringHeader(int byteCount) -> void +static readonly MessagePack.MessagePackSecurity.TrustedData -> MessagePack.MessagePackSecurity! +static readonly MessagePack.MessagePackSecurity.UntrustedData -> MessagePack.MessagePackSecurity! +virtual MessagePack.MessagePackSecurity.Clone() -> MessagePack.MessagePackSecurity! +virtual MessagePack.MessagePackSecurity.GetHashCollisionResistantEqualityComparer() -> System.Collections.IEqualityComparer! +virtual MessagePack.MessagePackSecurity.GetHashCollisionResistantEqualityComparer() -> System.Collections.Generic.IEqualityComparer! +MessagePack.Formatters.ByteMemoryFormatter +MessagePack.Formatters.ByteMemoryFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Memory +MessagePack.Formatters.ByteMemoryFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Memory value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ByteReadOnlyMemoryFormatter +MessagePack.Formatters.ByteReadOnlyMemoryFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.ReadOnlyMemory +MessagePack.Formatters.ByteReadOnlyMemoryFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.ReadOnlyMemory value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ByteReadOnlySequenceFormatter +MessagePack.Formatters.ByteReadOnlySequenceFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Buffers.ReadOnlySequence +MessagePack.Formatters.ByteReadOnlySequenceFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Buffers.ReadOnlySequence value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ExpandoObjectFormatter +MessagePack.Formatters.ExpandoObjectFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Dynamic.ExpandoObject? +MessagePack.Formatters.ExpandoObjectFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Dynamic.ExpandoObject? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ForceTypelessFormatter +MessagePack.Formatters.ForceTypelessFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T? +MessagePack.Formatters.ForceTypelessFormatter.ForceTypelessFormatter() -> void +MessagePack.Formatters.ForceTypelessFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.MemoryFormatter +MessagePack.Formatters.MemoryFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Memory +MessagePack.Formatters.MemoryFormatter.MemoryFormatter() -> void +MessagePack.Formatters.MemoryFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Memory value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NonGenericInterfaceCollectionFormatter +MessagePack.Formatters.NonGenericInterfaceCollectionFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Collections.ICollection? +MessagePack.Formatters.NonGenericInterfaceCollectionFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Collections.ICollection? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.NonGenericInterfaceEnumerableFormatter +MessagePack.Formatters.NonGenericInterfaceEnumerableFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Collections.IEnumerable? +MessagePack.Formatters.NonGenericInterfaceEnumerableFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Collections.IEnumerable? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.PrimitiveObjectFormatter.PrimitiveObjectFormatter() -> void +MessagePack.Formatters.ReadOnlyMemoryFormatter +MessagePack.Formatters.ReadOnlyMemoryFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.ReadOnlyMemory +MessagePack.Formatters.ReadOnlyMemoryFormatter.ReadOnlyMemoryFormatter() -> void +MessagePack.Formatters.ReadOnlyMemoryFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.ReadOnlyMemory value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.ReadOnlySequenceFormatter +MessagePack.Formatters.ReadOnlySequenceFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.Buffers.ReadOnlySequence +MessagePack.Formatters.ReadOnlySequenceFormatter.ReadOnlySequenceFormatter() -> void +MessagePack.Formatters.ReadOnlySequenceFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Buffers.ReadOnlySequence value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.TypeFormatter +MessagePack.Formatters.TypeFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> T? +MessagePack.Formatters.TypeFormatter.Serialize(ref MessagePack.MessagePackWriter writer, T? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.TypelessFormatter.TypelessFormatter() -> void +MessagePack.ImmutableCollection.ImmutableArrayFormatter +~MessagePack.ImmutableCollection.ImmutableArrayFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions options) -> System.Collections.Immutable.ImmutableArray +MessagePack.ImmutableCollection.ImmutableArrayFormatter.ImmutableArrayFormatter() -> void +~MessagePack.ImmutableCollection.ImmutableArrayFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.Collections.Immutable.ImmutableArray value, MessagePack.MessagePackSerializerOptions options) -> void +MessagePack.ImmutableCollection.ImmutableCollectionResolver +MessagePack.ImmutableCollection.ImmutableCollectionResolver.GetFormatter() -> MessagePack.Formatters.IMessagePackFormatter? +MessagePack.ImmutableCollection.ImmutableDictionaryFormatter +MessagePack.ImmutableCollection.ImmutableDictionaryFormatter.ImmutableDictionaryFormatter() -> void +MessagePack.ImmutableCollection.ImmutableHashSetFormatter +MessagePack.ImmutableCollection.ImmutableHashSetFormatter.ImmutableHashSetFormatter() -> void +MessagePack.ImmutableCollection.ImmutableListFormatter +MessagePack.ImmutableCollection.ImmutableListFormatter.ImmutableListFormatter() -> void +MessagePack.ImmutableCollection.ImmutableQueueBuilder +MessagePack.ImmutableCollection.ImmutableQueueBuilder.Add(T value) -> void +MessagePack.ImmutableCollection.ImmutableQueueBuilder.ImmutableQueueBuilder() -> void +~MessagePack.ImmutableCollection.ImmutableQueueBuilder.Q.get -> System.Collections.Immutable.ImmutableQueue +~MessagePack.ImmutableCollection.ImmutableQueueBuilder.Q.set -> void +MessagePack.ImmutableCollection.ImmutableQueueFormatter +MessagePack.ImmutableCollection.ImmutableQueueFormatter.ImmutableQueueFormatter() -> void +MessagePack.ImmutableCollection.ImmutableSortedDictionaryFormatter +MessagePack.ImmutableCollection.ImmutableSortedDictionaryFormatter.ImmutableSortedDictionaryFormatter() -> void +MessagePack.ImmutableCollection.ImmutableSortedSetFormatter +MessagePack.ImmutableCollection.ImmutableSortedSetFormatter.ImmutableSortedSetFormatter() -> void +MessagePack.ImmutableCollection.ImmutableStackFormatter +MessagePack.ImmutableCollection.ImmutableStackFormatter.ImmutableStackFormatter() -> void +MessagePack.ImmutableCollection.InterfaceImmutableDictionaryFormatter +MessagePack.ImmutableCollection.InterfaceImmutableDictionaryFormatter.InterfaceImmutableDictionaryFormatter() -> void +MessagePack.ImmutableCollection.InterfaceImmutableListFormatter +MessagePack.ImmutableCollection.InterfaceImmutableListFormatter.InterfaceImmutableListFormatter() -> void +MessagePack.ImmutableCollection.InterfaceImmutableQueueFormatter +MessagePack.ImmutableCollection.InterfaceImmutableQueueFormatter.InterfaceImmutableQueueFormatter() -> void +MessagePack.ImmutableCollection.InterfaceImmutableSetFormatter +MessagePack.ImmutableCollection.InterfaceImmutableSetFormatter.InterfaceImmutableSetFormatter() -> void +MessagePack.ImmutableCollection.InterfaceImmutableStackFormatter +MessagePack.ImmutableCollection.InterfaceImmutableStackFormatter.InterfaceImmutableStackFormatter() -> void +MessagePack.Resolvers.ExpandoObjectResolver +~override MessagePack.ImmutableCollection.ImmutableDictionaryFormatter.Add(System.Collections.Immutable.ImmutableDictionary.Builder collection, int index, TKey key, TValue value, MessagePack.MessagePackSerializerOptions options) -> void +~override MessagePack.ImmutableCollection.ImmutableDictionaryFormatter.Complete(System.Collections.Immutable.ImmutableDictionary.Builder intermediateCollection) -> System.Collections.Immutable.ImmutableDictionary +~override MessagePack.ImmutableCollection.ImmutableDictionaryFormatter.Create(int count, MessagePack.MessagePackSerializerOptions options) -> System.Collections.Immutable.ImmutableDictionary.Builder +~override MessagePack.ImmutableCollection.ImmutableDictionaryFormatter.GetSourceEnumerator(System.Collections.Immutable.ImmutableDictionary source) -> System.Collections.Immutable.ImmutableDictionary.Enumerator +~override MessagePack.ImmutableCollection.ImmutableHashSetFormatter.Add(System.Collections.Immutable.ImmutableHashSet.Builder collection, int index, T value, MessagePack.MessagePackSerializerOptions options) -> void +~override MessagePack.ImmutableCollection.ImmutableHashSetFormatter.Complete(System.Collections.Immutable.ImmutableHashSet.Builder intermediateCollection) -> System.Collections.Immutable.ImmutableHashSet +~override MessagePack.ImmutableCollection.ImmutableHashSetFormatter.Create(int count, MessagePack.MessagePackSerializerOptions options) -> System.Collections.Immutable.ImmutableHashSet.Builder +~override MessagePack.ImmutableCollection.ImmutableHashSetFormatter.GetSourceEnumerator(System.Collections.Immutable.ImmutableHashSet source) -> System.Collections.Immutable.ImmutableHashSet.Enumerator +~override MessagePack.ImmutableCollection.ImmutableListFormatter.Add(System.Collections.Immutable.ImmutableList.Builder collection, int index, T value, MessagePack.MessagePackSerializerOptions options) -> void +~override MessagePack.ImmutableCollection.ImmutableListFormatter.Complete(System.Collections.Immutable.ImmutableList.Builder intermediateCollection) -> System.Collections.Immutable.ImmutableList +~override MessagePack.ImmutableCollection.ImmutableListFormatter.Create(int count, MessagePack.MessagePackSerializerOptions options) -> System.Collections.Immutable.ImmutableList.Builder +~override MessagePack.ImmutableCollection.ImmutableListFormatter.GetSourceEnumerator(System.Collections.Immutable.ImmutableList source) -> System.Collections.Immutable.ImmutableList.Enumerator +~override MessagePack.ImmutableCollection.ImmutableQueueFormatter.Add(MessagePack.ImmutableCollection.ImmutableQueueBuilder collection, int index, T value, MessagePack.MessagePackSerializerOptions options) -> void +~override MessagePack.ImmutableCollection.ImmutableQueueFormatter.Complete(MessagePack.ImmutableCollection.ImmutableQueueBuilder intermediateCollection) -> System.Collections.Immutable.ImmutableQueue +~override MessagePack.ImmutableCollection.ImmutableQueueFormatter.Create(int count, MessagePack.MessagePackSerializerOptions options) -> MessagePack.ImmutableCollection.ImmutableQueueBuilder +~override MessagePack.ImmutableCollection.ImmutableSortedDictionaryFormatter.Add(System.Collections.Immutable.ImmutableSortedDictionary.Builder collection, int index, TKey key, TValue value, MessagePack.MessagePackSerializerOptions options) -> void +~override MessagePack.ImmutableCollection.ImmutableSortedDictionaryFormatter.Complete(System.Collections.Immutable.ImmutableSortedDictionary.Builder intermediateCollection) -> System.Collections.Immutable.ImmutableSortedDictionary +~override MessagePack.ImmutableCollection.ImmutableSortedDictionaryFormatter.Create(int count, MessagePack.MessagePackSerializerOptions options) -> System.Collections.Immutable.ImmutableSortedDictionary.Builder +~override MessagePack.ImmutableCollection.ImmutableSortedDictionaryFormatter.GetSourceEnumerator(System.Collections.Immutable.ImmutableSortedDictionary source) -> System.Collections.Immutable.ImmutableSortedDictionary.Enumerator +~override MessagePack.ImmutableCollection.ImmutableSortedSetFormatter.Add(System.Collections.Immutable.ImmutableSortedSet.Builder collection, int index, T value, MessagePack.MessagePackSerializerOptions options) -> void +~override MessagePack.ImmutableCollection.ImmutableSortedSetFormatter.Complete(System.Collections.Immutable.ImmutableSortedSet.Builder intermediateCollection) -> System.Collections.Immutable.ImmutableSortedSet +~override MessagePack.ImmutableCollection.ImmutableSortedSetFormatter.Create(int count, MessagePack.MessagePackSerializerOptions options) -> System.Collections.Immutable.ImmutableSortedSet.Builder +~override MessagePack.ImmutableCollection.ImmutableSortedSetFormatter.GetSourceEnumerator(System.Collections.Immutable.ImmutableSortedSet source) -> System.Collections.Immutable.ImmutableSortedSet.Enumerator +~override MessagePack.ImmutableCollection.ImmutableStackFormatter.Add(T[] collection, int index, T value, MessagePack.MessagePackSerializerOptions options) -> void +~override MessagePack.ImmutableCollection.ImmutableStackFormatter.Complete(T[] intermediateCollection) -> System.Collections.Immutable.ImmutableStack +~override MessagePack.ImmutableCollection.ImmutableStackFormatter.Create(int count, MessagePack.MessagePackSerializerOptions options) -> T[] +~override MessagePack.ImmutableCollection.InterfaceImmutableDictionaryFormatter.Add(System.Collections.Immutable.ImmutableDictionary.Builder collection, int index, TKey key, TValue value, MessagePack.MessagePackSerializerOptions options) -> void +~override MessagePack.ImmutableCollection.InterfaceImmutableDictionaryFormatter.Complete(System.Collections.Immutable.ImmutableDictionary.Builder intermediateCollection) -> System.Collections.Immutable.IImmutableDictionary +~override MessagePack.ImmutableCollection.InterfaceImmutableDictionaryFormatter.Create(int count, MessagePack.MessagePackSerializerOptions options) -> System.Collections.Immutable.ImmutableDictionary.Builder +~override MessagePack.ImmutableCollection.InterfaceImmutableListFormatter.Add(System.Collections.Immutable.ImmutableList.Builder collection, int index, T value, MessagePack.MessagePackSerializerOptions options) -> void +~override MessagePack.ImmutableCollection.InterfaceImmutableListFormatter.Complete(System.Collections.Immutable.ImmutableList.Builder intermediateCollection) -> System.Collections.Immutable.IImmutableList +~override MessagePack.ImmutableCollection.InterfaceImmutableListFormatter.Create(int count, MessagePack.MessagePackSerializerOptions options) -> System.Collections.Immutable.ImmutableList.Builder +~override MessagePack.ImmutableCollection.InterfaceImmutableQueueFormatter.Add(MessagePack.ImmutableCollection.ImmutableQueueBuilder collection, int index, T value, MessagePack.MessagePackSerializerOptions options) -> void +~override MessagePack.ImmutableCollection.InterfaceImmutableQueueFormatter.Complete(MessagePack.ImmutableCollection.ImmutableQueueBuilder intermediateCollection) -> System.Collections.Immutable.IImmutableQueue +~override MessagePack.ImmutableCollection.InterfaceImmutableQueueFormatter.Create(int count, MessagePack.MessagePackSerializerOptions options) -> MessagePack.ImmutableCollection.ImmutableQueueBuilder +~override MessagePack.ImmutableCollection.InterfaceImmutableSetFormatter.Add(System.Collections.Immutable.ImmutableHashSet.Builder collection, int index, T value, MessagePack.MessagePackSerializerOptions options) -> void +~override MessagePack.ImmutableCollection.InterfaceImmutableSetFormatter.Complete(System.Collections.Immutable.ImmutableHashSet.Builder intermediateCollection) -> System.Collections.Immutable.IImmutableSet +~override MessagePack.ImmutableCollection.InterfaceImmutableSetFormatter.Create(int count, MessagePack.MessagePackSerializerOptions options) -> System.Collections.Immutable.ImmutableHashSet.Builder +~override MessagePack.ImmutableCollection.InterfaceImmutableStackFormatter.Add(T[] collection, int index, T value, MessagePack.MessagePackSerializerOptions options) -> void +~override MessagePack.ImmutableCollection.InterfaceImmutableStackFormatter.Complete(T[] intermediateCollection) -> System.Collections.Immutable.IImmutableStack +~override MessagePack.ImmutableCollection.InterfaceImmutableStackFormatter.Create(int count, MessagePack.MessagePackSerializerOptions options) -> T[] +static readonly MessagePack.Formatters.ByteMemoryFormatter.Instance -> MessagePack.Formatters.ByteMemoryFormatter! +static readonly MessagePack.Formatters.ByteReadOnlyMemoryFormatter.Instance -> MessagePack.Formatters.ByteReadOnlyMemoryFormatter! +static readonly MessagePack.Formatters.ByteReadOnlySequenceFormatter.Instance -> MessagePack.Formatters.ByteReadOnlySequenceFormatter! +static readonly MessagePack.Formatters.ExpandoObjectFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.NonGenericInterfaceCollectionFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.NonGenericInterfaceEnumerableFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.Formatters.TypeFormatter.Instance -> MessagePack.Formatters.IMessagePackFormatter! +static readonly MessagePack.ImmutableCollection.ImmutableCollectionResolver.Instance -> MessagePack.ImmutableCollection.ImmutableCollectionResolver! +static readonly MessagePack.Resolvers.ExpandoObjectResolver.Instance -> MessagePack.IFormatterResolver! +static readonly MessagePack.Resolvers.ExpandoObjectResolver.Options -> MessagePack.MessagePackSerializerOptions! +virtual MessagePack.Formatters.PrimitiveObjectFormatter.DeserializeMap(ref MessagePack.MessagePackReader reader, int length, MessagePack.MessagePackSerializerOptions! options) -> object! +MessagePack.ExtensionHeader.ExtensionHeader() -> void +MessagePack.ExtensionResult.ExtensionResult() -> void +MessagePack.FormatterNotRegisteredException.FormatterNotRegisteredException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void +MessagePack.MessagePackReader.MessagePackReader() -> void +MessagePack.MessagePackSerializerOptions.SequencePool.get -> MessagePack.SequencePool! +MessagePack.MessagePackSerializerOptions.WithPool(MessagePack.SequencePool! pool) -> MessagePack.MessagePackSerializerOptions! +MessagePack.MessagePackStreamReader.MessagePackStreamReader(System.IO.Stream! stream, bool leaveOpen, MessagePack.SequencePool! sequencePool) -> void +MessagePack.MessagePackStreamReader.ReadArrayHeaderAsync(System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.ValueTask +MessagePack.MessagePackStreamReader.ReadMapHeaderAsync(System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.ValueTask +MessagePack.MessagePackWriter.MessagePackWriter() -> void +MessagePack.SequencePool +MessagePack.SequencePool.SequencePool() -> void +MessagePack.SequencePool.SequencePool(int maxSize) -> void +MessagePack.SequencePool.SequencePool(int maxSize, System.Buffers.ArrayPool! arrayPool) -> void +MessagePack.TinyJsonException.TinyJsonException(System.Runtime.Serialization.SerializationInfo! info, System.Runtime.Serialization.StreamingContext context) -> void +static MessagePack.Nil.operator !=(MessagePack.Nil left, MessagePack.Nil right) -> bool +static MessagePack.Nil.operator ==(MessagePack.Nil left, MessagePack.Nil right) -> bool +virtual MessagePack.MessagePackStreamReader.Dispose(bool disposing) -> void +MessagePack.Formatters.GenericEnumerableFormatter +MessagePack.Formatters.GenericEnumerableFormatter.GenericEnumerableFormatter() -> void +MessagePack.Formatters.GenericReadOnlyDictionaryFormatter +MessagePack.Formatters.GenericReadOnlyDictionaryFormatter.GenericReadOnlyDictionaryFormatter() -> void +MessagePack.Formatters.StringInterningFormatter +MessagePack.Formatters.StringInterningFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> string? +MessagePack.Formatters.StringInterningFormatter.Serialize(ref MessagePack.MessagePackWriter writer, string? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.StringInterningFormatter.StringInterningFormatter() -> void +MessagePack.MessagePackSerializerOptions.CompressionMinLength.get -> int +MessagePack.MessagePackSerializerOptions.SuggestedContiguousMemorySize.get -> int +MessagePack.MessagePackSerializerOptions.WithCompressionMinLength(int compressionMinLength) -> MessagePack.MessagePackSerializerOptions! +MessagePack.MessagePackSerializerOptions.WithSuggestedContiguousMemorySize(int suggestedContiguousMemorySize) -> MessagePack.MessagePackSerializerOptions! +static MessagePack.MessagePackWriter.GetEncodedLength(long value) -> int +static MessagePack.MessagePackWriter.GetEncodedLength(ulong value) -> int diff --git a/src/MessagePack/net472/PublicAPI.Unshipped.txt b/src/MessagePack/net472/PublicAPI.Unshipped.txt new file mode 100644 index 000000000..e69de29bb diff --git a/src/MessagePack/net6.0/PublicAPI.Shipped.txt b/src/MessagePack/net6.0/PublicAPI.Shipped.txt index 159e4b86c..2c67e9468 100644 --- a/src/MessagePack/net6.0/PublicAPI.Shipped.txt +++ b/src/MessagePack/net6.0/PublicAPI.Shipped.txt @@ -1179,3 +1179,21 @@ MessagePack.Formatters.GenericEnumerableFormatter MessagePack.Formatters.GenericEnumerableFormatter.GenericEnumerableFormatter() -> void MessagePack.Formatters.GenericReadOnlyDictionaryFormatter MessagePack.Formatters.GenericReadOnlyDictionaryFormatter.GenericReadOnlyDictionaryFormatter() -> void +MessagePack.Formatters.DateOnlyFormatter +MessagePack.Formatters.DateOnlyFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.DateOnly +MessagePack.Formatters.DateOnlyFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.DateOnly value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.StringInterningFormatter +MessagePack.Formatters.StringInterningFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> string? +MessagePack.Formatters.StringInterningFormatter.Serialize(ref MessagePack.MessagePackWriter writer, string? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.StringInterningFormatter.StringInterningFormatter() -> void +MessagePack.Formatters.TimeOnlyFormatter +MessagePack.Formatters.TimeOnlyFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.TimeOnly +MessagePack.Formatters.TimeOnlyFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.TimeOnly value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.MessagePackSerializerOptions.CompressionMinLength.get -> int +MessagePack.MessagePackSerializerOptions.SuggestedContiguousMemorySize.get -> int +MessagePack.MessagePackSerializerOptions.WithCompressionMinLength(int compressionMinLength) -> MessagePack.MessagePackSerializerOptions! +MessagePack.MessagePackSerializerOptions.WithSuggestedContiguousMemorySize(int suggestedContiguousMemorySize) -> MessagePack.MessagePackSerializerOptions! +static MessagePack.MessagePackWriter.GetEncodedLength(long value) -> int +static MessagePack.MessagePackWriter.GetEncodedLength(ulong value) -> int +static readonly MessagePack.Formatters.DateOnlyFormatter.Instance -> MessagePack.Formatters.DateOnlyFormatter! +static readonly MessagePack.Formatters.TimeOnlyFormatter.Instance -> MessagePack.Formatters.TimeOnlyFormatter! diff --git a/src/MessagePack/net6.0/PublicAPI.Unshipped.txt b/src/MessagePack/net6.0/PublicAPI.Unshipped.txt index 432231fd1..e69de29bb 100644 --- a/src/MessagePack/net6.0/PublicAPI.Unshipped.txt +++ b/src/MessagePack/net6.0/PublicAPI.Unshipped.txt @@ -1,18 +0,0 @@ -MessagePack.Formatters.DateOnlyFormatter -MessagePack.Formatters.DateOnlyFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.DateOnly -MessagePack.Formatters.DateOnlyFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.DateOnly value, MessagePack.MessagePackSerializerOptions! options) -> void -MessagePack.Formatters.StringInterningFormatter -MessagePack.Formatters.StringInterningFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> string? -MessagePack.Formatters.StringInterningFormatter.Serialize(ref MessagePack.MessagePackWriter writer, string? value, MessagePack.MessagePackSerializerOptions! options) -> void -MessagePack.Formatters.StringInterningFormatter.StringInterningFormatter() -> void -MessagePack.Formatters.TimeOnlyFormatter -MessagePack.Formatters.TimeOnlyFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> System.TimeOnly -MessagePack.Formatters.TimeOnlyFormatter.Serialize(ref MessagePack.MessagePackWriter writer, System.TimeOnly value, MessagePack.MessagePackSerializerOptions! options) -> void -MessagePack.MessagePackSerializerOptions.CompressionMinLength.get -> int -MessagePack.MessagePackSerializerOptions.SuggestedContiguousMemorySize.get -> int -MessagePack.MessagePackSerializerOptions.WithCompressionMinLength(int compressionMinLength) -> MessagePack.MessagePackSerializerOptions! -MessagePack.MessagePackSerializerOptions.WithSuggestedContiguousMemorySize(int suggestedContiguousMemorySize) -> MessagePack.MessagePackSerializerOptions! -static MessagePack.MessagePackWriter.GetEncodedLength(long value) -> int -static MessagePack.MessagePackWriter.GetEncodedLength(ulong value) -> int -static readonly MessagePack.Formatters.DateOnlyFormatter.Instance -> MessagePack.Formatters.DateOnlyFormatter! -static readonly MessagePack.Formatters.TimeOnlyFormatter.Instance -> MessagePack.Formatters.TimeOnlyFormatter! diff --git a/src/MessagePack/netstandard2.0/PublicAPI.Shipped.txt b/src/MessagePack/netstandard2.0/PublicAPI.Shipped.txt index 0a13c4956..2893efd85 100644 --- a/src/MessagePack/netstandard2.0/PublicAPI.Shipped.txt +++ b/src/MessagePack/netstandard2.0/PublicAPI.Shipped.txt @@ -1173,3 +1173,13 @@ MessagePack.Formatters.GenericEnumerableFormatter MessagePack.Formatters.GenericEnumerableFormatter.GenericEnumerableFormatter() -> void MessagePack.Formatters.GenericReadOnlyDictionaryFormatter MessagePack.Formatters.GenericReadOnlyDictionaryFormatter.GenericReadOnlyDictionaryFormatter() -> void +MessagePack.Formatters.StringInterningFormatter +MessagePack.Formatters.StringInterningFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> string? +MessagePack.Formatters.StringInterningFormatter.Serialize(ref MessagePack.MessagePackWriter writer, string? value, MessagePack.MessagePackSerializerOptions! options) -> void +MessagePack.Formatters.StringInterningFormatter.StringInterningFormatter() -> void +MessagePack.MessagePackSerializerOptions.CompressionMinLength.get -> int +MessagePack.MessagePackSerializerOptions.SuggestedContiguousMemorySize.get -> int +MessagePack.MessagePackSerializerOptions.WithCompressionMinLength(int compressionMinLength) -> MessagePack.MessagePackSerializerOptions! +MessagePack.MessagePackSerializerOptions.WithSuggestedContiguousMemorySize(int suggestedContiguousMemorySize) -> MessagePack.MessagePackSerializerOptions! +static MessagePack.MessagePackWriter.GetEncodedLength(long value) -> int +static MessagePack.MessagePackWriter.GetEncodedLength(ulong value) -> int diff --git a/src/MessagePack/netstandard2.0/PublicAPI.Unshipped.txt b/src/MessagePack/netstandard2.0/PublicAPI.Unshipped.txt index d78a588a7..e69de29bb 100644 --- a/src/MessagePack/netstandard2.0/PublicAPI.Unshipped.txt +++ b/src/MessagePack/netstandard2.0/PublicAPI.Unshipped.txt @@ -1,10 +0,0 @@ -MessagePack.Formatters.StringInterningFormatter -MessagePack.Formatters.StringInterningFormatter.Deserialize(ref MessagePack.MessagePackReader reader, MessagePack.MessagePackSerializerOptions! options) -> string? -MessagePack.Formatters.StringInterningFormatter.Serialize(ref MessagePack.MessagePackWriter writer, string? value, MessagePack.MessagePackSerializerOptions! options) -> void -MessagePack.Formatters.StringInterningFormatter.StringInterningFormatter() -> void -MessagePack.MessagePackSerializerOptions.CompressionMinLength.get -> int -MessagePack.MessagePackSerializerOptions.SuggestedContiguousMemorySize.get -> int -MessagePack.MessagePackSerializerOptions.WithCompressionMinLength(int compressionMinLength) -> MessagePack.MessagePackSerializerOptions! -MessagePack.MessagePackSerializerOptions.WithSuggestedContiguousMemorySize(int suggestedContiguousMemorySize) -> MessagePack.MessagePackSerializerOptions! -static MessagePack.MessagePackWriter.GetEncodedLength(long value) -> int -static MessagePack.MessagePackWriter.GetEncodedLength(ulong value) -> int diff --git a/src/MessagePackAnalyzer/MessagePackAnalyzer.cs b/src/MessagePackAnalyzer/MessagePackAnalyzer.cs index e903c57ad..e7b6281a9 100644 --- a/src/MessagePackAnalyzer/MessagePackAnalyzer.cs +++ b/src/MessagePackAnalyzer/MessagePackAnalyzer.cs @@ -80,7 +80,14 @@ public override void Initialize(AnalysisContext context) { if (ReferenceSymbols.TryCreate(ctxt.Compilation, out ReferenceSymbols? typeReferences)) { - ctxt.RegisterSyntaxNodeAction(c => Analyze(c, typeReferences), SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration); + var relevantSyntaxKinds = new[] + { + SyntaxKind.ClassDeclaration, + SyntaxKind.StructDeclaration, + SyntaxKind.InterfaceDeclaration, + SyntaxKind.RecordDeclaration, + }; + ctxt.RegisterSyntaxNodeAction(c => Analyze(c, typeReferences), relevantSyntaxKinds); } }); } diff --git a/src/MessagePackAnalyzer/MessagePackAnalyzer.csproj b/src/MessagePackAnalyzer/MessagePackAnalyzer.csproj index 18b3579d5..85c8faba1 100644 --- a/src/MessagePackAnalyzer/MessagePackAnalyzer.csproj +++ b/src/MessagePackAnalyzer/MessagePackAnalyzer.csproj @@ -1,6 +1,7 @@  netstandard2.0 + true Analyzer of MessagePack for C#, verify rule for [MessagePackObject] and code fix for [Key]. MsgPack;MessagePack;Serialization;Formatter;Analyzer diff --git a/src/MessagePackAnalyzer/MessagePackCodeFixProvider.cs b/src/MessagePackAnalyzer/MessagePackCodeFixProvider.cs index c4b7c1028..57ce0ede5 100644 --- a/src/MessagePackAnalyzer/MessagePackCodeFixProvider.cs +++ b/src/MessagePackAnalyzer/MessagePackCodeFixProvider.cs @@ -154,12 +154,26 @@ private static async Task AddKeyAttributeAsync(Document document, INam foreach (ISymbol member in targets) { - if (member.GetAttributes().FindAttributeShortName(MessagePackAnalyzer.KeyAttributeShortName) is null) + if (!member.IsImplicitlyDeclared && + member.GetAttributes().FindAttributeShortName(MessagePackAnalyzer.KeyAttributeShortName) is null) { SyntaxNode node = await member.DeclaringSyntaxReferences[0].GetSyntaxAsync(cancellationToken).ConfigureAwait(false); var documentEditor = await solutionEditor.GetDocumentEditorAsync(document.Project.Solution.GetDocumentId(node.SyntaxTree), cancellationToken).ConfigureAwait(false); var syntaxGenerator = SyntaxGenerator.GetGenerator(documentEditor.OriginalDocument); - documentEditor.AddAttribute(node, syntaxGenerator.Attribute("MessagePack.KeyAttribute", syntaxGenerator.LiteralExpression(startOrder++))); + AttributeListSyntax attributeList = (AttributeListSyntax)syntaxGenerator.Attribute("MessagePack.KeyAttribute", syntaxGenerator.LiteralExpression(startOrder++)); + if (node is ParameterSyntax parameter) + { + // The primary constructor requires special target on the attribute list. + attributeList = attributeList.WithTarget( + SyntaxFactory.AttributeTargetSpecifier(SyntaxFactory.Token(SyntaxKind.PropertyKeyword))) + .WithLeadingTrivia(parameter.GetLeadingTrivia()); + ParameterSyntax attributedParameter = parameter.AddAttributeLists(attributeList); + documentEditor.ReplaceNode(parameter, attributedParameter); + } + else + { + documentEditor.AddAttribute(node, attributeList); + } } } diff --git a/tests/MessagePack.Generator.Tests/GenerateStringKeyedFormatterTest.cs b/tests/MessagePack.Generator.Tests/GenerateStringKeyedFormatterTest.cs index 1719fb5fa..2815b8636 100644 --- a/tests/MessagePack.Generator.Tests/GenerateStringKeyedFormatterTest.cs +++ b/tests/MessagePack.Generator.Tests/GenerateStringKeyedFormatterTest.cs @@ -863,5 +863,67 @@ await compiler.GenerateFileAsync( ((string)result.B).Should().Be("foobar"); // default value }); } + + [Fact] + public async Task StringKeyAttributeMapModeTest() + { + using var tempWorkarea = TemporaryProjectWorkarea.Create(); + var contents = @" +using System; +using System.Collections.Generic; +using MessagePack; + +namespace TempProject +{ + [MessagePackObject] + public class MyMessagePackObject + { + [Key(""a"")] + public int A { get; set; } + [Key(""b"")] + public string B { get; set; } + } +} + "; + tempWorkarea.AddFileToTargetProject("MyMessagePackObject.cs", contents); + + var compiler = new MessagePackCompiler.CodeGenerator(testOutputHelper.WriteLine, CancellationToken.None); + await compiler.GenerateFileAsync( + tempWorkarea.GetOutputCompilation().Compilation, + tempWorkarea.OutputDirectory, + "TempProjectResolver", + "TempProject.Generated", + true, + string.Empty, + Array.Empty()); + + var compilation = tempWorkarea.GetOutputCompilation(); + compilation.Compilation.GetDiagnostics().Should().NotContain(x => x.Severity == DiagnosticSeverity.Error); + + // Run tests with the generated resolver/formatter assembly. + compilation.ExecuteWithGeneratedAssembly((ctx, assembly) => + { + var mpoType = assembly.GetType("TempProject.MyMessagePackObject"); + var options = MessagePackSerializerOptions.Standard + .WithResolver(CompositeResolver.Create( + StandardResolver.Instance, + TestUtilities.GetResolverInstance(assembly, "TempProject.Generated.Resolvers.TempProjectResolver"))); + + // Build `{ "a": -1, "b": "foo" }` + var seq = new Sequence(); + var writer = new MessagePackWriter(seq); + writer.WriteMapHeader(2); + writer.Write("a"); + writer.Write(-1); + writer.Write("b"); + writer.Write("foo"); + writer.Flush(); + + // Verify deserialization + dynamic result = MessagePackSerializer.Deserialize(mpoType, seq, options); + ((int)result.A).Should().Be(-1); // from ctor + ((string)result.B).Should().Be("foo"); // default value + }); + } } } diff --git a/tests/MessagePack.Tests/ContractlessStandardResolverConstructorTests.cs b/tests/MessagePack.Tests/ContractlessStandardResolverConstructorTests.cs index 9a755c966..d92819ecd 100644 --- a/tests/MessagePack.Tests/ContractlessStandardResolverConstructorTests.cs +++ b/tests/MessagePack.Tests/ContractlessStandardResolverConstructorTests.cs @@ -85,6 +85,43 @@ public TestConstructor2(int x, int y, int z) } } + public class TestConstructor3 + { + private Guid x; + private Guid y; + + public TestConstructor3(Guid x, Guid y) + { + this.x = x; + this.y = y; + this.CalledConstructorParameterCount = 2; + } + + public int CalledConstructorParameterCount { get; } + + public Guid X + { + get => this.x; + set => this.x = value; + } + + public Guid Y + { + get => this.y; + set => this.y = value; + } + } + + [Fact] + public void UseConstructor3() + { + var ctor = new TestConstructor3(Guid.NewGuid(), Guid.NewGuid()); + var bin = MessagePackSerializer.Serialize(ctor, ContractlessStandardResolverAllowPrivate.Options); + var r = MessagePackSerializer.Deserialize(bin, ContractlessStandardResolverAllowPrivate.Options)!; + + r.CalledConstructorParameterCount.Is(2); + } + [Fact] public void UseConstructor() { @@ -95,6 +132,16 @@ public void UseConstructor() r.CalledConstructorParameterCount.Is(3); } + [Fact] + public void UseConstructor2() + { + var ctor = new TestConstructor1(10, 20, 30); + var bin = MessagePackSerializer.Serialize(ctor, ContractlessStandardResolver.Options); + var r = MessagePackSerializer.Deserialize(bin, ContractlessStandardResolver.Options); + + r.CalledConstructorParameterCount.Is(3); + } + [Fact] public void IgnorePropertiesWithoutConstructorArgument() { diff --git a/tests/MessagePack.Tests/MessagePack.Tests.csproj b/tests/MessagePack.Tests/MessagePack.Tests.csproj index f66b0f2fe..73f973ef5 100644 --- a/tests/MessagePack.Tests/MessagePack.Tests.csproj +++ b/tests/MessagePack.Tests/MessagePack.Tests.csproj @@ -11,6 +11,7 @@ + diff --git a/tests/MessagePackAnalyzer.Tests/Helpers/CSharpCodeFixVerifier`2.cs b/tests/MessagePackAnalyzer.Tests/Helpers/CSharpCodeFixVerifier`2.cs index 2fcb42a1a..ac4e942fb 100644 --- a/tests/MessagePackAnalyzer.Tests/Helpers/CSharpCodeFixVerifier`2.cs +++ b/tests/MessagePackAnalyzer.Tests/Helpers/CSharpCodeFixVerifier`2.cs @@ -1,6 +1,7 @@ // Copyright (c) All contributors. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. +using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CodeFixes; @@ -22,26 +23,26 @@ public static DiagnosticResult Diagnostic(string diagnosticId) public static DiagnosticResult Diagnostic(DiagnosticDescriptor descriptor) => new DiagnosticResult(descriptor); - public static Task VerifyAnalyzerWithoutMessagePackReferenceAsync(string source) + public static Task VerifyAnalyzerWithoutMessagePackReferenceAsync([StringSyntax("c#-test")] string source) { var test = new Test { TestCode = source, ReferenceAssemblies = ReferenceAssemblies.NetFramework.Net472.Default }; return test.RunAsync(); } - public static Task VerifyAnalyzerAsync(string source, params DiagnosticResult[] expected) + public static Task VerifyAnalyzerAsync([StringSyntax("c#-test")] string source, params DiagnosticResult[] expected) { var test = new Test { TestCode = source }; test.ExpectedDiagnostics.AddRange(expected); return test.RunAsync(); } - public static Task VerifyCodeFixAsync(string source, string fixedSource) + public static Task VerifyCodeFixAsync([StringSyntax("c#-test")] string source, [StringSyntax("c#-test")] string fixedSource) => VerifyCodeFixAsync(source, DiagnosticResult.EmptyDiagnosticResults, fixedSource); - public static Task VerifyCodeFixAsync(string source, DiagnosticResult expected, string fixedSource) + public static Task VerifyCodeFixAsync([StringSyntax("c#-test")] string source, DiagnosticResult expected, [StringSyntax("c#-test")] string fixedSource) => VerifyCodeFixAsync(source, new[] { expected }, fixedSource); - public static Task VerifyCodeFixAsync(string source, DiagnosticResult[] expected, string fixedSource) + public static Task VerifyCodeFixAsync([StringSyntax("c#-test")] string source, DiagnosticResult[] expected, [StringSyntax("c#-test")] string fixedSource) { var test = new Test { @@ -53,7 +54,7 @@ public static Task VerifyCodeFixAsync(string source, DiagnosticResult[] expected return test.RunAsync(); } - public static Task VerifyCodeFixAsync(string[] source, string[] fixedSource) + public static Task VerifyCodeFixAsync([StringSyntax("c#-test")] string[] source, [StringSyntax("c#-test")] string[] fixedSource) { var test = new Test { diff --git a/tests/MessagePackAnalyzer.Tests/MessagePackAnalyzerTests.cs b/tests/MessagePackAnalyzer.Tests/MessagePackAnalyzerTests.cs index 8fc4c65f9..a22e5e62e 100644 --- a/tests/MessagePackAnalyzer.Tests/MessagePackAnalyzerTests.cs +++ b/tests/MessagePackAnalyzer.Tests/MessagePackAnalyzerTests.cs @@ -1,8 +1,10 @@ // Copyright (c) All contributors. All rights reserved. // Licensed under the MIT license. See LICENSE file in the project root for full license information. +using System.Collections.Immutable; using System.Threading.Tasks; -using Microsoft.CodeAnalysis; +using Microsoft.CodeAnalysis.CSharp; +using Microsoft.CodeAnalysis.CSharp.Testing; using Microsoft.CodeAnalysis.Testing; using Xunit; using VerifyCS = @@ -10,14 +12,14 @@ public class MessagePackAnalyzerTests { - private const string Preamble = @" + private const string Preamble = /* lang=c#-test */ @" using MessagePack; "; [Fact] public async Task NoMessagePackReference() { - string input = @" + string input = /* lang=c#-test */ @" public class Foo { } @@ -29,7 +31,7 @@ public class Foo [Fact] public async Task MessageFormatterAttribute() { - string input = Preamble + @"using MessagePack.Formatters; + string input = Preamble + /* lang=c#-test */ @"using MessagePack.Formatters; public class FooFormatter : IMessagePackFormatter { public void Serialize(ref MessagePackWriter writer, Foo value, MessagePackSerializerOptions options) {} @@ -55,7 +57,7 @@ public class SomeClass { [Fact] public async Task InvalidMessageFormatterType() { - string input = Preamble + @"using MessagePack.Formatters; + string input = Preamble + /* lang=c#-test */ @"using MessagePack.Formatters; public class InvalidMessageFormatter { } @@ -77,7 +79,7 @@ public class SomeClass { [Fact] public async Task NullStringKey() { - string input = Preamble + @" + string input = Preamble + /* lang=c#-test */ @" [MessagePackObject] public class Foo { @@ -92,7 +94,7 @@ public class Foo [Fact] public async Task AddAttributesToMembers() { - string input = Preamble + @" + string input = Preamble + /* lang=c#-test */ @" [MessagePackObject] public class Foo { @@ -101,7 +103,7 @@ public class Foo } "; - string output = Preamble + @" + string output = Preamble + /* lang=c#-test */ @" [MessagePackObject] public class Foo { @@ -119,7 +121,7 @@ public class Foo public async Task AddAttributeToType() { // Don't use Preamble because we want to test that it works without a using statement at the top. - string input = @" + string input = /* lang=c#-test */ @" public class Foo { public string Member { get; set; } @@ -133,7 +135,7 @@ public class Bar } "; - string output = @" + string output = /* lang=c#-test */ @" [MessagePack.MessagePackObject] public class Foo { @@ -157,13 +159,13 @@ public async Task CodeFixAppliesAcrossFiles() { var inputs = new string[] { - @" + /* lang=c#-test */ @" public class Foo { public int {|MsgPack004:Member1|} { get; set; } } ", - @"using MessagePack; + /* lang=c#-test */ @"using MessagePack; [MessagePackObject] public class Bar : Foo @@ -174,14 +176,14 @@ public class Bar : Foo }; var outputs = new string[] { - @" + /* lang=c#-test */ @" public class Foo { [MessagePack.Key(1)] public int Member1 { get; set; } } ", - @"using MessagePack; + /* lang=c#-test */ @"using MessagePack; [MessagePackObject] public class Bar : Foo @@ -194,4 +196,75 @@ public class Bar : Foo await VerifyCS.VerifyCodeFixAsync(inputs, outputs); } + + [Fact] + public async Task AddAttributesToMembersOfRecord() + { + string input = Preamble + /* lang=c#-test */ @" +[MessagePackObject] +public record Foo +{ + public string {|MsgPack004:Member1|} { get; set; } + public string {|MsgPack004:Member2|} { get; set; } +} +"; + + string output = Preamble + /* lang=c#-test */ @" +[MessagePackObject] +public record Foo +{ + [Key(0)] + public string Member1 { get; set; } + [Key(1)] + public string Member2 { get; set; } +} +"; + await new VerifyCS.Test + { + ReferenceAssemblies = ReferenceAssemblies.Net.Net60.WithPackages(ImmutableArray.Create(new PackageIdentity("MessagePack", "2.0.335"))), + CompilerDiagnostics = CompilerDiagnostics.Errors, + SolutionTransforms = + { + static (solution, projectId) => + { + return solution.WithProjectParseOptions(projectId, new CSharpParseOptions(languageVersion: LanguageVersion.CSharp11)); + }, + }, + TestCode = input, + FixedCode = output, + }.RunAsync(); + } + + [Fact] + public async Task AddAttributesToMembersOfRecordWithPrimaryCtor() + { + string input = Preamble + /* lang=c#-test */ @" +[MessagePackObject] +public record Foo( + string {|MsgPack004:Member1|}, + string {|MsgPack004:Member2|}); +"; + + string output = Preamble + /* lang=c#-test */ @" +[MessagePackObject] +public record Foo( + [property: Key(0)] string {|MsgPack004:Member1|}, + [property: Key(1)] string {|MsgPack004:Member2|}); +"; + + await new VerifyCS.Test + { + ReferenceAssemblies = ReferenceAssemblies.Net.Net60.WithPackages(ImmutableArray.Create(new PackageIdentity("MessagePack", "2.0.335"))), + CompilerDiagnostics = CompilerDiagnostics.Errors, + SolutionTransforms = + { + static (solution, projectId) => + { + return solution.WithProjectParseOptions(projectId, new CSharpParseOptions(languageVersion: LanguageVersion.CSharp11)); + }, + }, + TestCode = input, + FixedCode = output, + }.RunAsync(); + } }