使用 SOLID 原则序列化自定义对象

Question

我想序列化包含纯数据的模型对象（来自 WPF MVVM）。这听起来很简单，但我不想使用 .NET 框架中提供的序列化属性和内容。我只是想用我自己的方式序列化它。
所以这是我的 classes 之一的简化版本。

public class EntryKeyValuePair 
{
    public EntryKeyValuePair(string key, string value, bool isMultiline = false, bool isMandatory = true, bool isProtected = false)
    {
        Key = key;
        Value = value;
        IsMultiline = isMultiline;
        IsMandatory = isMandatory;
        IsProtected = isProtected;
    }

    public string Key { get; set; }
    public string Value { get; set; }
    public bool IsMultiline { get; set; }
    public bool IsMandatory { get; set; }
    public bool IsProtected { get; set; }

    public static EntryKeyValuePair FromXML(XElement element, ICipher cipher)
    {
        string key = cipher.Decrypt(element.Element(nameof(Key)).Value);
        string value = cipher.Decrypt(element.Element(nameof(Value)).Value);
        bool isMultiline = bool.Parse(element.Element(nameof(IsMultiline)).Value);
        bool isMandatory = bool.Parse(element.Element(nameof(IsMandatory)).Value);
        bool isProtected = bool.Parse(element.Element(nameof(IsProtected)).Value);
        return new EntryKeyValuePair(key, value, isMultiline, isMandatory, isProtected);
    }

    public XElement ToXML(ICipher cipher)
    {
        return new XElement(nameof(EntryKeyValuePair),
                                new XElement(nameof(Key),cipher.Encrypt(Key)),
                                new XElement(nameof(Value), cipher.Encrypt(Value)),
                                new XElement(nameof(IsMultiline), IsMultiline), new XElement(nameof(IsMandatory), IsMandatory),
                                new XElement(nameof(IsProtected), IsProtected));
    }
}

这个效果很好。但这违反了单一责任原则，也可能违反了其他原则。这也很难维护和扩展。
所以我想另辟蹊径。这是：

首先我定义了一个 IStringFormatter 接口，它可以将数据格式化为任何字符串数据格式，如 XML 和 JSON。（不确定）

interface IStringFormatter
{
    string Name { get; set; }
    Dictionary<string, string> FieldDictionary { get; }
    string Format();
}

下面是 XMLStringFormatter 的样子：

class XmlStringFormatter : IStringFormatter
{
    public XmlStringFormatter()
    {
        FieldDictionary = new Dictionary<string, string>();
    }

    public string Name { get; set; }
    public Dictionary<string, string> FieldDictionary { get; }

    public string Format()
    {
        var xElement = new XElement(Name, FieldDictionary.Keys.Select(key => new XElement(key, FieldDictionary[key])));
        return xElement.ToString();
    }
}

然后我定义了一个 ISerializer 来将我的数据对象序列化（或者说保存）到 IStringFormatter。

interface ISerializer<T>
{
    T DeSerialize(IStringFormatter stringFormatter);
    void Serialize(T obj, IStringFormatter stringFormatter);
}

下面是我 "Serialize" EntryKeyValurPair 的实现方式：

internal class EntryKeyValurPairSerializer : ISerializer<EntryKeyValuePair>
{
    public EntryKeyValuePair DeSerialize(IStringFormatter stringFormatter)
    {
        Dictionary<string, string> fieldDictionary = stringFormatter.FieldDictionary;

        try {
            string key = fieldDictionary[nameof(EntryKeyValuePair.Key)];
            string value = fieldDictionary[nameof(EntryKeyValuePair.Value)];
            bool isMandatory = bool.Parse(fieldDictionary[nameof(EntryKeyValuePair.IsMandatory)]);
            bool isProtected = bool.Parse(fieldDictionary[nameof(EntryKeyValuePair.IsProtected)]);
            bool isMultiline = bool.Parse(fieldDictionary[nameof(EntryKeyValuePair.IsMultiline)]);
            return new EntryKeyValuePair(key, value, isMultiline, isMandatory, isProtected);
        }
        catch (KeyNotFoundException ex) {
            throw new SerializationException(ex);
        }
        catch (FormatException ex) {
            throw new SerializationException(ex);
        }
    }

    public void Serialize(EntryKeyValuePair obj, IStringFormatter stringFormatter)
    {
        stringFormatter.Name = nameof(EntryKeyValuePair);
        Dictionary<string, string> fieldDictionary = stringFormatter.FieldDictionary;

        fieldDictionary.Add(nameof(EntryKeyValuePair.Key), obj.Key);
        fieldDictionary.Add(nameof(EntryKeyValuePair.Value), obj.Value);
        fieldDictionary.Add(nameof(EntryKeyValuePair.IsMandatory), obj.IsMandatory.ToString());
        fieldDictionary.Add(nameof(EntryKeyValuePair.IsProtected), obj.IsProtected.ToString());
        fieldDictionary.Add(nameof(EntryKeyValuePair.IsMultiline), obj.IsMultiline.ToString());
    }
}

现在可以正常工作了。但问题是当我的数据 classes.
中有像 List<Entry> 这样的复杂类型（其中 Entry 是另一个数据 class）由于 IStringFormatter 包含 Dictionary<string, string>，我不能只将 List<Entry> 转换为字符串，因为我不知道它在上下文中需要哪种 IStringFormatter ISerializer。我怎样才能解决这个问题？我还想知道我的解决方案是否遵守 SOLID 原则。如果您能提出更好的解决方案（不是典型的 .NET 序列化），我将不胜感激。

Answer 1

编写自己的序列化程序可能是一项有趣的任务，但我怀疑这是不是一个好主意。

据我所知，您想保持模型干净，没有任何序列化特定属性。我猜 "typical .NET serialization" 是指 .Net 框架中包含的方法。

为简单起见，我们将使用这些简单的 classes 作为示例：

class Customer
{
    public string Name { get; set; }
    public int Age { get; set; }
    public List<Order> Orders { get; set; }     
}

class Order 
{
    public int Id { get; set; }
    public string Details { get; set; }
}

一个简单的选择是使用 Json.NET:

var customer = new Customer 
{ 
    Name = "Darth Vader", 
    Age = 45,
    Orders = new List<Order> 
    {
        new Order { Id = 1, Details = "Order1" },
        new Order { Id = 2, Details = "Order2" }
    }
};
string json = JsonConvert.SerializeObject(customer);

如您所见，您不需要向 Customer class 添加任何自定义属性。它会一直工作，直到您想要序列化所有 public 属性。

结果 JSON 将是：

{
  "Name": "Darth Vader",
  "Age": 45,
  "Orders": [
    {
      "Id": 1,
      "Details": "Order1"
    },
    {
      "Id": 2,
      "Details": "Order2"
    }
  ]
}

之后你可以随时反序列化它：

var customer = JsonConvert.DeserializeObject<Customer>(json);

假设您不希望包含 Age 属性。在这种情况下，我建议创建一个仅用于序列化的不同 class：

class CostomerSerializationContract
{
    public string Name { get; set; }
    public List<Order> Orders { get; set; }
}

这种方法的主要优点是您有单独的 class 用于序列化，并且您可以在其中添加任何自定义属性，如果您选择使用其他一些序列化程序，而不会违反 SOLID 原则。主要缺点是您需要手动保持两个对象同步。

从源 class 创建序列化合约时，您可以使用 AutoMapper 减少手动工作。

使用 SOLID 原则序列化自定义对象

Serializing a custom object using SOLID principles

c#

oop

serialization

solid-principles