Question

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

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);
}

以下是我＆＃34;序列化＆＃34; 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());
    }
}

现在这很好用。但问题是我的数据类中有一个类似List<Entry>的复杂类型（其中Entry是另一个数据类）。
由于IStringFormatter包含Dictionary<string, string>，我无法将List<Entry>转换为字符串，因为我不知道它需要什么样的IStringFormatter在ISerializer的背景下。我怎样才能解决这个问题？我也想知道我的解决方案是否符合SOLID原则。如果您可以建议更好的解决方案（不是典型的.NET序列化），我将不胜感激。

Answer 1

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

据我了解，您希望保持模型清洁，没有任何序列化特定属性。我想通过＆＃34;典型的.NET序列化＆＃34;你的意思是.Net框架中包含的方法。

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

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课程添加任何自定义属性。它将一直有效，直到您想要序列化所有公共属性。

生成的JSON将是：

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

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

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

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

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

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

从源类创建序列化合同时，可以使用AutoMapper来减少手动工作。

使用SOLID原则

1 个答案: