C# 重构静态类和方法（Json序列化/反序列化）

我曾经为我的Json数据创建过一个类。然而，我并不真正理解为什么创建帮助器方法来从json转换为json，并提供默认参数，它们分别作为类的静态方法、静态类和带有静态方法的类创建

真正的原因是，只要我从另一组json数据创建第二个类，代码就会因为静态类而失败，我希望确保正确重构它们。当然也要理解其中的原因

我认为“Converter”在我所有的json对象中都不会改变，所以我可以将其原样移动到一个单独的文件中，并使用FromJson序列化为一个静态方法。但我只是想更多地了解它最初是如何实现的，以及更好的方法

代码如下：

public partial class StationDO
{
    public string Active { get; set; }
    //more fields here
}

public partial class StationDO
    {
        public static List<StationDO> FromJson(string json)
        {
            return JsonConvert.DeserializeObject<List<StationDO>>(json, Converter.Settings);
        }
    }

    public static class Serialize
    {
        public static string ToJson(this List<StationDO> self)
        {
            return JsonConvert.SerializeObject(self, Converter.Settings);
        }
    }

    public class Converter
    {
        public static readonly JsonSerializerSettings Settings = new JsonSerializerSettings
        {
            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
            DateParseHandling = DateParseHandling.None,
        };
    }

公共部分类StationDO
{
公共字符串活动{get；set；}
//这里有更多的田地
}
公共部分类站
{
来自json的公共静态列表（字符串json）
{
返回JsonConvert.DeserializeObject（json，Converter.Settings）；
}
}
公共静态类序列化
{
公共静态字符串ToJson（此列表本身）
{
返回JsonConvert.SerializeObject（self，Converter.Settings）；
}
}
公共类转换器
{
公共静态只读JsonSerializerSettings设置=新JsonSerializerSettings
{
MetadataPropertyHandling=MetadataPropertyHandling.Ignore，
DateParseHandling=DateParseHandling.None，
};
}

---

如果我看一下同一个站点生成的Java代码，它只是将bean之外的所有内容放入一个类“转换器”

您可以在

StationDO

类中拥有所有静态成员。在这种情况下，我建议将该类标记为sealed（

public sealed class StationDO

），以防止有人从该类继承，并使用继承类的静态方法

public class InheritedStationDO : StationDO { }
// ... somewhere else ...
InheritedStationDO.FromJson(jsonValue); // still returns List<StationDO> not List<InheritedStationDO> !!!

公共类继承的StationDO:StationDO{}
// ... 在别的地方。。。
继承的stationdo.FromJson（jsonValue）；//仍然返回列表而不是列表！！！

编辑：

public class StationDO {
    public string Active { get; set; }
}

public class AnotherDO {
    public string Name { get; set; }
}

// and more *DO classes

// class need to be "static" because contains "extension methods"
public static class MySerializationHelper {
    private static readonly JsonSerializerSettings serializationSettings = new JsonSerializerSettings
        {
            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
            DateParseHandling = DateParseHandling.None,
        };

    // universal method for deserialization from json
    // the generic type "T" represents the result type of deserialization
    public static T FromJson<T>(string json) {
        return JsonConvert.DeserializeObject<T>(json, serializationSettings);
    }

    // universal method for serialization to json
    // this "this" keyword means, its "extension method"
    public static string ToJson<T>(this T self) {
        return JsonConvert.SerializeObject(self, serializationSettings);
    }
}

StationDO obj01 = GetSomeStation();

// returns json of one object
string json01A = obj01.ToJson(); // these two lines are equivalent
string json01B = MySerializationHelper.ToJson(obj01); // these two lines are equivalent

// returns new object deserialized from json in "json01" variable
StationDO clone01 = MySerializationHelper.FromJson<StationDO>(json01A);

StationDO obj02 = GetAnotherStation();
StationDO[] arr01 = new StationDO[] { obj01, obj02 };

// returns json of array with two objects
string json02A = arr01.ToJson(); // these two lines are equivalent
string json02B = MySerializationHelper.ToJson(arr01); // these two lines are equivalent

// returns new array with deserialized object from json in "json02" variable
StationdDO[] clone02 = MySerializationHelper.FromJson<StationdDO[]>(json02A);

AnotherDO obj03 = GetAnotherDO();
string json03A = obj03.ToJson(); // these two lines are equivalent
string json03B = MySerializationHelper.ToJson(obj03); // these two lines are equivalent

仔细一看，我认为，整个设计的成员是不好的

1） 不需要只接受

列表

2） 不需要为每个类的（反）序列化定义特殊方法，您将拥有。对于所有类，只能有一个序列化方法和一个反序列化方法

示例：

public class StationDO {
    public string Active { get; set; }
}

public class AnotherDO {
    public string Name { get; set; }
}

// and more *DO classes

// class need to be "static" because contains "extension methods"
public static class MySerializationHelper {
    private static readonly JsonSerializerSettings serializationSettings = new JsonSerializerSettings
        {
            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
            DateParseHandling = DateParseHandling.None,
        };

    // universal method for deserialization from json
    // the generic type "T" represents the result type of deserialization
    public static T FromJson<T>(string json) {
        return JsonConvert.DeserializeObject<T>(json, serializationSettings);
    }

    // universal method for serialization to json
    // this "this" keyword means, its "extension method"
    public static string ToJson<T>(this T self) {
        return JsonConvert.SerializeObject(self, serializationSettings);
    }
}

StationDO obj01 = GetSomeStation();

// returns json of one object
string json01A = obj01.ToJson(); // these two lines are equivalent
string json01B = MySerializationHelper.ToJson(obj01); // these two lines are equivalent

// returns new object deserialized from json in "json01" variable
StationDO clone01 = MySerializationHelper.FromJson<StationDO>(json01A);

StationDO obj02 = GetAnotherStation();
StationDO[] arr01 = new StationDO[] { obj01, obj02 };

// returns json of array with two objects
string json02A = arr01.ToJson(); // these two lines are equivalent
string json02B = MySerializationHelper.ToJson(arr01); // these two lines are equivalent

// returns new array with deserialized object from json in "json02" variable
StationdDO[] clone02 = MySerializationHelper.FromJson<StationdDO[]>(json02A);

AnotherDO obj03 = GetAnotherDO();
string json03A = obj03.ToJson(); // these two lines are equivalent
string json03B = MySerializationHelper.ToJson(obj03); // these two lines are equivalent

public class StationDO{
公共字符串活动{get；set；}
}
公共类另一个{
公共字符串名称{get；set；}
}
//还有更多的课程
//类需要是“静态”的，因为它包含“扩展方法”
公共静态类MySerializationHelper{
私有静态只读JsonSerializerSettings serializationSettings=新JsonSerializerSettings
{
MetadataPropertyHandling=MetadataPropertyHandling.Ignore，
DateParseHandling=DateParseHandling.None，
};
//从json反序列化的通用方法
//泛型类型“T”表示反序列化的结果类型
公共静态T FromJson（字符串json）{
返回JsonConvert.DeserializeObject（json，serializationSettings）；
}
//json序列化的通用方法
//这个“this”关键字意味着它的“扩展方法”
公共静态字符串ToJson（这个T self）{
返回JsonConvert.SerializeObject（self，serializationSettings）；
}
}

用法：

public class StationDO {
    public string Active { get; set; }
}

public class AnotherDO {
    public string Name { get; set; }
}

// and more *DO classes

// class need to be "static" because contains "extension methods"
public static class MySerializationHelper {
    private static readonly JsonSerializerSettings serializationSettings = new JsonSerializerSettings
        {
            MetadataPropertyHandling = MetadataPropertyHandling.Ignore,
            DateParseHandling = DateParseHandling.None,
        };

    // universal method for deserialization from json
    // the generic type "T" represents the result type of deserialization
    public static T FromJson<T>(string json) {
        return JsonConvert.DeserializeObject<T>(json, serializationSettings);
    }

    // universal method for serialization to json
    // this "this" keyword means, its "extension method"
    public static string ToJson<T>(this T self) {
        return JsonConvert.SerializeObject(self, serializationSettings);
    }
}

StationDO obj01 = GetSomeStation();

// returns json of one object
string json01A = obj01.ToJson(); // these two lines are equivalent
string json01B = MySerializationHelper.ToJson(obj01); // these two lines are equivalent

// returns new object deserialized from json in "json01" variable
StationDO clone01 = MySerializationHelper.FromJson<StationDO>(json01A);

StationDO obj02 = GetAnotherStation();
StationDO[] arr01 = new StationDO[] { obj01, obj02 };

// returns json of array with two objects
string json02A = arr01.ToJson(); // these two lines are equivalent
string json02B = MySerializationHelper.ToJson(arr01); // these two lines are equivalent

// returns new array with deserialized object from json in "json02" variable
StationdDO[] clone02 = MySerializationHelper.FromJson<StationdDO[]>(json02A);

AnotherDO obj03 = GetAnotherDO();
string json03A = obj03.ToJson(); // these two lines are equivalent
string json03B = MySerializationHelper.ToJson(obj03); // these two lines are equivalent

StationDO obj01=GetSomeStation（）；
//返回一个对象的json
字符串json01A=obj01.ToJson（）；//这两条线是相等的
字符串json01B=MySerializationHelper.ToJson（obj01）；//这两条线是相等的
//在“json01”变量中返回从json反序列化的新对象
StationDO clone01=MySerializationHelper.FromJson（json01A）；
StationDO obj02=GetAnotherStation（）；
StationDO[]arr01=新StationDO[]{obj01，obj02}；
//返回包含两个对象的数组的json
字符串json02A=arr01.ToJson（）；//这两条线是相等的
字符串json02B=MySerializationHelper.ToJson（arr01）；//这两条线是相等的
//在“json02”变量中从json返回具有反序列化对象的新数组
StationdDO[]clone02=MySerializationHelper.FromJson（json02A）；
AnotherDO obj03=GetAnotherDO（）；
字符串json03A=obj03.ToJson（）；//这两条线是相等的
字符串json03B=MySerializationHelper.ToJson（obj03）；//这两条线是相等的

如您所见，泛型是避免每个类的代码重复的方法。

---

您可以（反）序列化所有类型的数组和集合或单个对象。不仅仅是

列表

是的，谢谢。我只是想更好地理解为什么这三件事是这样做的背后的逻辑？起初，我认为“Serialize”是json.net或.net使用的一种神奇名称……当我这样做时，我得到了“扩展方法必须在非泛型静态类中定义”。所以我不能让整个类都是静态的，因为我可能有不止一个StationDO？在.net中，魔法名称非常少，通常你甚至不需要知道它们。从技术上讲，在这种情况下不需要嵌套类。可能“Serialize”类是出于某种语法目的，允许您编写“StationDO.Serialize.ToJson（myList）”。@TcKs Serialize不是嵌套类。哦，我注意到了“this”关键字。也就是说，这是扩展方法，我将扩展答案。