能否仅通过泛型生成指定格式JSON？替代匿名类型方案咨询

我定义了如下泛型类：

public class Generic<T>
{
   public T Data {get; set;}
}

目前我通过创建匿名对象并赋值给Generic<object>的Data属性，序列化后得到了目标格式的JSON：

var r1 = new {
    A = lstA,
    validation = null as ValidationError
}

var r2 = new {
    B = lstB,
    validation = null as ValidationError
}

赋值代码：

Generic<object> g1 = new Generic<object>();
g1.Data = r1;

Generic<object> g2 = new Generic<object>();
g2.Data = r2;

序列化后的JSON格式为：

{
   "Data":{
      "A":[
         {
            
         }
      ],
      "validation":null
   }
}

{
   "Data":{
      "B":[
         {
            
         }
      ],
      "validation":null
   }
}

其中JSON中的键名（如A、B）会动态变化。我想咨询：能否仅通过泛型实现上述指定格式的JSON？是否有更优的实现方式？

1. 仅用泛型实现的可行性 #

直接用纯泛型类没法生成动态键名——因为泛型是编译时确定类型的，而动态键名是运行时才确定的特性。但可以结合泛型和其他特性达成目标：

方式一：泛型+动态类型（dynamic） #

修改泛型类的Data属性为dynamic类型，这样就能在运行时动态添加属性：

public class Generic<T>
{
    public dynamic Data { get; set; }
}

// 使用示例
var g1 = new Generic<List<YourTypeA>>();
g1.Data = new { A = lstA, validation = (ValidationError)null };

var g2 = new Generic<List<YourTypeB>>();
g2.Data = new { B = lstB, validation = (ValidationError)null };

这种方式还是借助了匿名对象的动态特性，但泛型类可以约束Data中集合的类型，比Generic<object>更有类型安全性。

方式二：泛型+自定义字典序列化 #

如果不想用匿名对象，可以定义泛型类，内部包含字典和validation属性，再通过序列化配置让字典的键直接作为JSON的顶级键：

public class GenericResponse<T>
{
    public Dictionary<string, T> DataDict { get; set; }
    public ValidationError validation { get; set; }
}

// 以Newtonsoft.Json为例，需要自定义ContractResolver让DataDict的键平铺到Data对象中
var settings = new JsonSerializerSettings
{
    ContractResolver = new CustomContractResolver()
};
// 自定义ContractResolver逻辑略，核心是把DataDict的键值对和validation合并到同一个JSON对象里

不过这种方式需要写额外的序列化逻辑，不如匿名对象简洁。

2. 更优的实现方式 #

推荐：泛型封装方法简化重复代码 #

既然匿名对象已经能满足需求，不如封装一个泛型方法来减少重复代码：

public static Generic<object> CreateGenericResponse<T>(string dynamicKey, T data, ValidationError validation = null)
{
    var responseData = new Dictionary<string, object>
    {
        { dynamicKey, data },
        { "validation", validation }
    };
    return new Generic<object> { Data = responseData };
}

// 使用时一行搞定
var g1 = CreateGenericResponse("A", lstA);
var g2 = CreateGenericResponse("B", lstB);

这种方式既保留了动态键名的灵活性，又通过泛型约束了数据类型，代码复用性更高。

进阶：直接操作JSON结构 #

如果用Newtonsoft.Json或System.Text.Json，可以直接构建JSON对象，甚至不用定义Generic<T>类：

// Newtonsoft.Json示例
var jsonObj = new JObject(
    new JProperty("Data", new JObject(
        new JProperty("A", JArray.FromObject(lstA)),
        new JProperty("validation", (JToken)null)
    ))
);
string jsonStr = jsonObj.ToString();

// System.Text.Json示例
var dataObj = new JsonObject();
dataObj.Add("B", JsonSerializer.SerializeToElement(lstB));
dataObj.Add("validation", JsonValue.CreateNull());
var rootObj = new JsonObject();
rootObj.Add("Data", dataObj);
string jsonStr = JsonSerializer.Serialize(rootObj);

这种方式完全绕开了实体类，直接生成目标JSON，适合高度动态的场景。

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