在AspNet Core WebAPI与控制台应用中实现MessagePack的序列化反序列化问题

嘿，我来一步步帮你搞定这些MessagePack的实操问题，刚好之前在类似的场景里折腾过，给你分享下落地的方案：

1. 客户端如何反序列化对象？ #

首先得确保你的实体类已经正确配置了MessagePack的特性，比如给类加上[MessagePackObject]，给属性加上[Key(0)]这类标记（或者用ContractlessStandardResolver免标记，但生产环境更推荐显式标记）。

控制台客户端这边，当你从API拿到MessagePack格式的响应字节流后，直接用MessagePackSerializer.Deserialize<T>就能搞定：

// 假设你用HttpClient调用API
var httpClient = new HttpClient();
// 记得请求头指定Accept为MessagePack的媒体类型
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/x-msgpack"));

var response = await httpClient.GetAsync("https://your-api-url/endpoint");
response.EnsureSuccessStatusCode();

// 获取响应字节流
var responseBytes = await response.Content.ReadAsByteArrayAsync();
// 反序列化为目标类型
var yourObject = MessagePackSerializer.Deserialize<YourTargetType>(responseBytes);

如果你的类型有继承或者复杂结构，可以提前配置序列化器的Resolver，比如：

var options = MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance);
var yourObject = MessagePackSerializer.Deserialize<YourTargetType>(responseBytes, options);

2. 客户端向API回传对象的正确姿势 #

不建议序列化后转成字符串再发，因为MessagePack是二进制格式，转字符串会额外引入Base64编码的开销，完全没必要。更高效的方式是直接发送二进制字节流：

客户端代码： #

var yourObject = new YourTargetType { /* 填充属性 */ };
// 序列化为字节数组
var objectBytes = MessagePackSerializer.Serialize(yourObject);

// 创建ByteArrayContent来发送二进制数据
var content = new ByteArrayContent(objectBytes);
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-msgpack");

var httpClient = new HttpClient();
var response = await httpClient.PostAsync("https://your-api-url/your-post-endpoint", content);
response.EnsureSuccessStatusCode();

API端接收： #

如果你的API已经配置了MessagePack的MediaTypeFormatter（比如在Startup/Program.cs里加了services.AddControllers().AddMessagePackFormatters()），直接用[FromBody]就能自动反序列化：

[HttpPost]
public IActionResult Post([FromBody] YourTargetType model)
{
    // 直接使用model即可，框架已经帮你完成反序列化
    return Ok();
}

如果是手动处理字节流的话（比如API接收byte[]），那就在Action里自己反序列化：

[HttpPost]
public async Task<IActionResult> Post()
{
    var requestBytes = await Request.Body.ReadAllBytesAsync();
    var model = MessagePackSerializer.Deserialize<YourTargetType>(requestBytes);
    // 处理逻辑
    return Ok();
}

3. 如何传递类型信息？ #

MessagePack本身是无类型的二进制格式，默认序列化时不会携带类型信息，如果你需要在反序列化时动态识别类型，有几种常用方案：

方案一：使用MessagePack的无类型序列化器 #

MessagePack提供了MessagePackSerializer.Typeless来序列化/反序列化带类型信息的对象，这样反序列化时不需要提前知道类型：

// 客户端序列化时用Typeless
var objectBytes = MessagePackSerializer.Typeless.Serialize(yourObject);

// API端反序列化时直接拿到原类型对象
var obj = MessagePackSerializer.Typeless.Deserialize(requestBytes);
if (obj is YourTargetType model)
{
    // 处理逻辑
}

这种方式简单，但会在序列化结果里嵌入类型的AssemblyQualifiedName，可能会有版本兼容性问题，适合内部系统使用。

方案二：自定义请求头传递类型标识 #

自己在请求里加一个自定义Header，比如X-Message-Type，把目标类型的全名（或者自定义的类型编码）传过去，API端根据这个标识来确定反序列化的类型：

// 客户端发送时加Header
var content = new ByteArrayContent(objectBytes);
content.Headers.ContentType = new MediaTypeHeaderValue("application/x-msgpack");
content.Headers.Add("X-Message-Type", typeof(YourTargetType).AssemblyQualifiedName);

// API端接收时读取Header
var typeName = Request.Headers["X-Message-Type"].FirstOrDefault();
var targetType = Type.GetType(typeName);
var model = MessagePackSerializer.Deserialize(targetType, requestBytes);

这种方式更灵活，你可以自己控制类型标识的格式，避免AssemblyQualifiedName的版本问题。

方案三：使用Union标记多态类型 #

如果你的场景是固定的几个多态类型，可以用[Union]特性标记基类，这样序列化时会自动携带类型标识：

[MessagePackObject]
[Union(0, typeof(ConcreteType1))]
[Union(1, typeof(ConcreteType2))]
public abstract class BaseType
{
    // 基类属性
}

[MessagePackObject]
public class ConcreteType1 : BaseType
{
    [Key(0)]
    public string Prop1 { get; set; }
}

// 客户端序列化子类
var obj = new ConcreteType1 { Prop1 = "test" };
var bytes = MessagePackSerializer.Serialize<BaseType>(obj);

// API端反序列化为基类，然后判断实际类型
var baseObj = MessagePackSerializer.Deserialize<BaseType>(bytes);
if (baseObj is ConcreteType1 concrete1)
{
    // 处理逻辑
}

这种方式类型安全，适合多态场景下的固定类型集合。

内容的提问来源于stack exchange，提问作者Optimus Prime