在 C# 中构建序列化程序的最有效方法

Question

I am currently building my own serializer and I'm at a point where I no longer want to misuse the System.Xml.Linq classes so I'm building my own.

Let's say I have these classes:

• XmlElement
• XmlAttribute
• XmlText

And let's assume these only have a Name property which returns string and a Value property which returns a IReadonlyList<IXmlNode> .

The question I have is, would it be more efficient to make the classes themselves responsible for writing out their own serialized value or would it be more efficient to have a class that uses pattern matching?

So for example option A :

public class XmlElement: IXmlNode {

    public void Write(StringBuilder stringBuilder) {

        stringBuilder.WriteLine($"<{Name}>")

        foreach(var child in Children) {
            child.Write(stringBuilder);
        }

        stringBuilder.WriteLine($"</{Name}>")

    }

}

Or option B :

public class XmlWriter {

    public string Write(IXmlNode node, StringBuilder passedStringBuilder) {

        var stringBuilder = passedStringBuilder ?? new StringBuilder();

        if (IXmlNode is XmlElement xmlElement) WriteElement(xmlElement, stringBuilder);
        if (IXmlNode is XmlAttribute xmlAttribute) WriteAttribute(xmlAttribute, stringBuilder);
        if (IXmlNode is XmlText xmlText) WriteText(xmlText, stringBuilder);

        return stringBuilder.ToString();
    }

    public void WriteElement(XmlElement element, stringBuilder) {

        stringBuilder.WriteLine($"<{element.Name}>")

        foreach(var child in element.Children) {
            Write(child, stringBuilder);
        }

        stringBuilder.WriteLine($"</{element.Name}>")

    }

}

Obviously there is more to writing an XML serializer, this isn't great code and I left out some parts here and there.
I'm mostly concerned about the concept of which would be most efficient.

Additional information

Since there have been some requests to define what I mean by efficiency here are some factors I'd like to score the implementation on:

• Speed
• Garbage collection
• Memory allocation

Of course code readability is also a factor however, at this point I've written both implementations and in regards of readability Option A has my preference. Option B resulted in quite some lines of code in a single file and arguably it's doing too much for one class.

So in short:
Unless Option B greatly outperforms Option A my preference will go towards Option A .

Answer 1

In this case I'd suppose the answer would be Option A .

What I did to test this:

• I created basic data types for JSON and XML which would write out their own serialized value when ToString was called
• I wrote some tests that would compare the output of an expected string representation to make sure the output was what I expected
• I created a basic implementation of a serializer for both a JSON and an XML datatype
• I added test cases to the existing tests to ensure the output of both solutions was the same
• I wrote a basic BenchmarkDotNet test for both options and both data types and ran that with a Bogus fueled data input of about 200 complex items as an initial sample

This is the result of the benchmark test:

// * Summary *

BenchmarkDotNet=v0.13.1, OS=Windows 10.0.19043.1288 (21H1/May2021Update)
Intel Core i7-8750H CPU 2.20GHz (Coffee Lake), 1 CPU, 12 logical and 6 physical cores
.NET SDK=5.0.402
  [Host]                                                                              : .NET Core 3.1.20 (CoreCLR 4.700.21.47003, CoreFX 4.700.21.47101), X64 RyuJIT
  BenchmarkDotNet, Version=0.13.1.0, Culture=neutral, PublicKeyToken=aa0ca2f9092cefc4 : .NET Core 3.1.20 (CoreCLR 4.700.21.47003, CoreFX 4.700.21.47101), X64 RyuJIT

Job=BenchmarkDotNet, Version=0.13.1.0, Culture=neutral, PublicKeyToken=aa0ca2f9092cefc4  MaxRelativeError=0.01  IterationCount=1
LaunchCount=5  RunStrategy=ColdStart  UnrollFactor=1
WarmupCount=1

|           Method |       Mean |     Error |   StdDev |       Gen 0 | Completed Work Items | Lock Contentions |      Gen 1 | Allocated |
|----------------- |-----------:|----------:|---------:|------------:|---------------------:|-----------------:|-----------:|----------:|
| JsonDataToSTring |   420.3 ms |  42.31 ms | 10.99 ms |  19000.0000 |               4.0000 |                - |  6000.0000 |    232 MB |
| SerialJsonWriter |   420.7 ms |  58.03 ms | 15.07 ms |  19000.0000 |               4.0000 |                - |  6000.0000 |    232 MB |
|  XmlDataToSTring | 1,012.1 ms | 342.95 ms | 89.06 ms | 145000.0000 |               4.0000 |                - | 35000.0000 |  1,036 MB |
|  SerialXmlWriter | 1,128.5 ms |  70.71 ms | 18.36 ms | 203000.0000 |               4.0000 |                - | 40000.0000 |  1,384 MB |

The benchmark test was not extensive by any means and I did not do a very in-depth evaluation because these results to me are pretty clear.

For both JSON and XML Option A scores best on time , garbage collection and memory allocation on a pretty small dataset.

In retrospect, I could've seen this coming because C# doesn't support tail recursion.
In fact, when I increased the data size I managed to crash my computer by profiling code that overflowed the stack.

PS: I don't think it's valuable to go into too much detail of how the data is generated because such a small dataset already made such a difference.