Add new transport based on MessagePack

.github/copilot-instructions.md

@@ -86,7 +86,7 @@ CI separates test execution by target framework and excludes `OpenRiaServices.Co
 - Follow `.editorconfig` and existing style in nearby files.
 - C# uses 4-space indentation and C# 14.0 (`src\Directory.Build.props`).
 - Framework projects enable recommended analysis mode and XML documentation generation.
-- New public, protected, and internal APIs should have XML documentation comments.
+- New public, protected, and internal APIs should have XML documentation comments, this is not required for assembly local ("private") types.
 - Release builds should not introduce warnings.
 - Assembly signing is enabled centrally in `src\Directory.Build.props`; framework and test projects use keys from `src\snk`.
 - Use existing libraries and patterns. Do not modernize unrelated legacy code while fixing a targeted issue.

NuGet/OpenRiaServices.Client.Core.nuspec

@@ -17,9 +17,18 @@
     <language>en-US</language>
     <tags>WCF RIA Services RIAServices Silverlight OpenRiaServices</tags>
     <dependencies>
-      <group targetFramework="net472" />
-      <group targetFramework="net8.0" />
-	  <group targetFramework="net8.0-windows7.0" />
+      <group targetFramework="net472">
+        <dependency id="Nerdbank.MessagePack" version="1.2.4" exclude="Build,Analyzers" />
+        <dependency id="System.IO.Hashing" version="10.0.9" exclude="Build,Analyzers" />
+      </group>
+      <group targetFramework="net8.0">
+        <dependency id="Nerdbank.MessagePack" version="1.2.4" exclude="Build,Analyzers" />
+        <dependency id="System.IO.Hashing" version="10.0.9" exclude="Build,Analyzers" />
+      </group>
+      <group targetFramework="net8.0-windows7.0">
+        <dependency id="Nerdbank.MessagePack" version="1.2.4" exclude="Build,Analyzers" />
+        <dependency id="System.IO.Hashing" version="10.0.9" exclude="Build,Analyzers" />
+      </group>
     </dependencies>
     <frameworkReferences>
       <group targetFramework="net8.0-windows7.0">

docs/messagepack-serialization.md

@@ -0,0 +1,29 @@
+# MessagePack serialization wire schema (draft)
+
+OpenRiaServices supports MessagePack with MIME type `application/vnd.msgpack`.
+
+## Request envelope (POST/QUERY/Submit)
+
+Top-level object map:
+
+- `Parameters`: map<string, value?>  
+  Parameter name to a MessagePack value serialized with the declared parameter type converter. `nil` means `null`.
+- `QueryOptions`: array of `ServiceQueryPart` (optional)
+- `IncludeTotalCount`: bool (optional)
+
+## Success response envelope
+
+Top-level object map:
+
+- `Result`: value?  
+  MessagePack value for the declared operation return type. `nil` means `null` / no value.
+
+## Fault response envelope
+
+Top-level object map:
+
+- `Fault`: `DomainServiceFault`
+## Notes
+
+- GET query behavior stays unchanged (URL-encoded query parameters).
+- Envelopes are map-based for schema/version tolerance.

src/MessagePackWorkarounds.md

@@ -0,0 +1,73 @@
+# Serialization Of Class hierarchies does not work
+
+Consider the following class hierarchy.
+Where A is annotated with `KnownTypeAttribute` for `B` and `C`.
+```
+A -> B -> C
+```
+
+A serializer for A can properly serialize and deserialize all 3 classes.
+A serializer for B does not work for objects of type `C`.
+
+Desired behaviour:
+ * Serializer for `A` can serialize/deserialize all 3 types (with a single discriminator)
+ * Serializer for `B` can serialize/deserialize B and C
+ * Can serialize/deserialize objects of known type based on "object" serializer
+ * Should work with existing code gen (basetype has all "known type" attribytes)
+ * No usage of surrogates/marshalling types
+
+Problems:
+* Using DerivedShapeMapping have the following issues
+   * Serialization of B using shape A suddenly use 2 discriminators `["B", ["B", ...] ]`
+   * Serialization of B`s derived classses does not pick the most specific instance , a bug??
+      * There is some sorting of DerivedShapeMapping based on inheritance,
+        but it can still pick the base instance instead of the actual type.
+        This is especially bad when B is abstract.
+        See `AI_Detail` class where derived types were serialized as `AI_Detail` insted of actual type.
+* Cannot add custom converter for types using built in 
+
+Workarounds:
+* Added a `ObjectConverter` class on client
+  * The `ObjectConverter` class has a custom "ReflectionTypeShapeProvider" with special assemblies specified
+    Also "unwrapping" of `IUnionTypeShape<T>` is needed to get the underlying "object serializer"
+     * This allows caching of the "ObjectSerializers"
+* Added `SurrogateConverter` class on server
+   * Create dynamic classes/instances with same name and properties (without KnownTypeAttributes)
+* To get Queries, Invoke and method parameters to work
+  *  See test : Inherit_Run_CUD_Delete_Derived which failes since abstract class cannot be deserialized
+      *  Maybe always serialize/deserialize using "base type" serializer ??
+           * MethodParametersConverter (Client)
+           * ChangeSetEntryConverter (Client) (entity actions)
+           * MessagePackHttpDomainClient.GetResponseEnvelopeType*  (client)
+           * MethodParametersConverter (server)
+           * MessagePackRequestSerializer.WriteQueryResponseAsync (server)
+           * MessagePackRequestSerializer.CreateInvokeResponseEnvelope (server)
+
+
+# Serializing using
+
+# Object and Union converter for same type cannot coexist
+
+Problems
+* Cannot get "object" converter for a specific Type, the converter is "always" UnionTypeShape
+* Converter Cache does dot distinguish betweeen `IUniontTypeShape<T>` and `IObjectTypeShape<T>`
+
+# Other bugs
+
+PolyType does not handle TestDomainServices.MockReport correctly, it generate a constructor takeing 6 arguments meaning
+serialization callbacks will note be executed.
+
+Resulting in failed test
+
+* Addin a ctor with required parameters still does not resolve the issue.
+* adding required parameters to ctor leads to duplicate parameters
+
+# Other todos etc
+
+* Creata a server side test corresponding to DomainClient_SubmitWithNonexistentDomainMethod
+  * Validate behaviour when client send entityAction that does not exist
+* Update generated code to handle TestDomainServices.MockReport issue with required members
+* Ensure whole class hierarchies are properly serialized/deserialized when using "object" serializer
+  * See " Maybe always serialize/deserialize using "base type" serializer ??" above
+  * PARTIALLY IMPLEMENTED (Queries only)
+     * `MessagePackHttpDomainClient.GetResponseEnvelopeType` + `MessagePackRequestSerializer.WriteQueryResponseAsync`

src/OpenRiaServices.Client.DomainClients.Http/Framework/Http/HttpDomainClient.cs

@@ -26,12 +26,12 @@ abstract class HttpDomainClient : DomainClient
         private static readonly ConcurrentDictionary<(Type serviceInterface, string operationName), MethodParameters> s_methodParametersCache = new ConcurrentDictionary<(Type serviceInterface, string operationName), MethodParameters>();
 
         private readonly OpenRiaServices.Client.DomainClients.HttpDomainClientFactory _factory;
-        private readonly Type _serviceInterface;
 
         /// <inheritdoc/>
         public override bool SupportsCancellation => true;
 
         private protected HttpClient HttpClient { get; }
+        private protected Type ServiceInterface { get; }
 
         private protected HttpDomainClient(HttpClient httpClient, Type serviceInterface, OpenRiaServices.Client.DomainClients.HttpDomainClientFactory factory)
         {
@@ -40,7 +40,7 @@ private protected HttpDomainClient(HttpClient httpClient, Type serviceInterface,
             ArgumentNullException.ThrowIfNull(factory);
 
             HttpClient = httpClient;
-            _serviceInterface = serviceInterface;
+            ServiceInterface = serviceInterface;
             _factory = factory;
         }
 
@@ -50,7 +50,7 @@ private protected HttpDomainClient(HttpClient httpClient, Type serviceInterface,
 
         private protected MethodParameters GetMethodParameters(string operationName)
         {
-            return s_methodParametersCache.GetOrAdd((_serviceInterface, operationName), static key => new MethodParameters(key.serviceInterface, key.operationName));
+            return s_methodParametersCache.GetOrAdd((ServiceInterface, operationName), static key => new MethodParameters(key.serviceInterface, key.operationName));
         }
 
         private protected string GetParameterValueAsString(string operationName, string parameterName, object parameterValue)

src/OpenRiaServices.Client.DomainClients.Http/Framework/Http/MetodParameters.cs

@@ -7,7 +7,7 @@ namespace OpenRiaServices.Client.DomainClients.Http
     /// <summary>
     /// A dictionary of parameter name and types for a method
     /// </summary>
-    internal class MethodParameters
+    internal sealed class MethodParameters
     {
         private readonly string _operationName;
         private readonly Dictionary<string, Type> _parameterNameAndTypeDictionary;