如何根据Azure Cosmos DB文档属性动态序列化ReadItemAsync()响应？

下面提供几种实用的解决思路，核心都是先识别文档类型，再完成针对性序列化：

方法1：先读取无类型文档，判断类型后再反序列化 #

先以通用格式（比如JObject或dynamic）读取文档，提取type字段后，再将其反序列化为对应的强类型对象。这种方式直观易懂，适合类型不多的场景：

// 第一步：读取原始文档为JObject
var response = await container.ReadItemAsync<JObject>(itemId, new PartitionKey(partitionKey));
JObject doc = response.Resource;

// 第二步：提取type字段判断类型
string docType = doc["type"]?.ToString();
object result = docType switch
{
    "dog" => doc.ToObject<Dog>(),
    "cat" => doc.ToObject<Cat>(),
    // 扩展其他类型分支
    _ => throw new NotSupportedException($"Unsupported document type: {docType}")
};

// 后续根据类型做对应处理
if (result is Dog dog)
{
    // 处理Dog类型业务逻辑
}

如果依赖Cosmos DB自带的序列化器，也可以用它来完成转换，避免额外依赖Newtonsoft.Json：

var serializer = container.ClientOptions.Serializer;
Dog dog = serializer.FromStream<Dog>(doc.ToStream());

方法2：利用多态序列化自动解析类型 #

通过配置JSON序列化器的多态规则，指定type字段作为类型判别器，直接读取为基类对象，序列化器会自动根据type值实例化对应的派生类。这种方式更优雅，适合类型较多或需要长期扩展的场景。

基于System.Text.Json的配置（Cosmos DB默认序列化器） #

先定义基类和派生类：

[JsonDerivedType(typeof(Dog), typeDiscriminator: "dog")]
[JsonDerivedType(typeof(Cat), typeDiscriminator: "cat")]
public class Animal
{
    public string type { get; set; }
    // 其他通用属性
}

public class Dog : Animal
{
    public string Breed { get; set; }
}

public class Cat : Animal
{
    public bool IsLazy { get; set; }
}

之后直接读取为基类，序列化器会自动转换为对应派生类：

var response = await container.ReadItemAsync<Animal>(itemId, new PartitionKey(partitionKey));
Animal animal = response.Resource;

if (animal is Dog dog)
{
    // 处理Dog逻辑
}
else if (animal is Cat cat)
{
    // 处理Cat逻辑
}

基于Newtonsoft.Json的配置（若自定义了序列化器） #

如果项目用Newtonsoft.Json作为Cosmos序列化器，可通过自定义转换器实现多态：

public class AnimalConverter : JsonConverter<Animal>
{
    public override Animal ReadJson(JsonReader reader, Type objectType, Animal existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        JObject obj = JObject.Load(reader);
        string type = obj["type"]?.ToString();
        return type switch
        {
            "dog" => obj.ToObject<Dog>(serializer),
            "cat" => obj.ToObject<Cat>(serializer),
            _ => throw new NotSupportedException($"Unsupported type: {type}")
        };
    }

    public override void WriteJson(JsonWriter writer, Animal value, JsonSerializer serializer)
    {
        serializer.Serialize(writer, value);
    }
}

// 配置Cosmos客户端时指定序列化器
var client = new CosmosClient(connectionString, new CosmosClientOptions
{
    Serializer = new NewtonsoftJsonCosmosSerializer(new JsonSerializerSettings
    {
        Converters = { new AnimalConverter() }
    })
});

之后同样直接读取Animal类型即可自动解析。

方法3：通过反射动态指定泛型类型 #

如果需要直接调用泛型版本的ReadItemAsync<T>，可以通过反射根据type字符串动态创建泛型方法并执行：

// 先读取文档的type字段（也可以只读取type字段减少数据传输）
var typeResponse = await container.ReadItemAsync<JObject>(itemId, new PartitionKey(partitionKey));
string docType = typeResponse.Resource["type"].ToString();

// 根据type字符串获取对应的Type对象
Type targetType = docType switch
{
    "dog" => typeof(Dog),
    "cat" => typeof(Cat),
    _ => throw new NotSupportedException($"Unsupported type: {docType}")
};

// 反射调用ReadItemAsync<T>
MethodInfo method = typeof(Container).GetMethod(nameof(Container.ReadItemAsync), new[] { typeof(string), typeof(PartitionKey) });
MethodInfo genericMethod = method.MakeGenericMethod(targetType);
Task<ItemResponse<object>> task = (Task<ItemResponse<object>>)genericMethod.Invoke(container, new object[] { itemId, new PartitionKey(partitionKey) });
ItemResponse<object> response = await task;

object result = response.Resource;
// 后续处理逻辑

这种方式灵活性高，但反射会带来一定性能开销，适合对性能要求不高或类型频繁变动的场景。

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