C# 配置文件存储各种序列化算法性能比较

本文比较多个方式进行配置文件的存储，对比各个不同算法的读写性能。在应用软件启动的时候，需要读取配置文件，但是启动的性能很重要，所以需要有一个很快的读取配置文件的方法。如果你不想看过程，那么请看拖动滚动条

本文将会比较三个世界上最好的序列化算法，一个是 json 、一个是 ProtoBuf 、一个是 wire

原来我的软件在启动的时候是需要读取很多个文件，因为每个模块的配置都不同，所有模块的配置都是模块自己查找配置文件读取，然而大家都知道，在机械硬盘，随机读取文件的性能很差。现在虽然很多用户都是使用固态硬盘，但是对于启动性能优化，还是要尽量减少在软件启动过程的读取文件。

我询问了奎爷，他是一位强大的程序员，他告诉我，谷歌浏览器把很多零碎的文件，如历史记录和密码都压缩为一个文件，这样的启动时候，顺序读取性能很快，所以浏览器才可以快速启动。

于是我就开始了准备把所有的模块的配置文件合为一个，在合并的时候需要做序列化，因为存在很多模块都是使用自己实现的方式进行序列化。

下面就是我进行对比各个算法的性能。

需要注意，在软件启动的时候，还需要计算 dll 加载的性能，也就是如果有一个dll可以提高序列化性能，但是这个 dll 加载性能很差，也是不能使用这个dll的。

定义

先定义一个简单的类，这个类用来存放数据，只有 key-value 的数据

    [ProtoContract]
    [Serializable]
    public class Foo
    {
        [ProtoMember(1)]
        public Dictionary<string, string> CurmobeKallbu { set; get; }
    }

在启动之前就需要读取这个文件作为配置，所以需要找到一个很快的方法从文件读取，然后反序列化。

为了方便序列化，我写了一个方法Foo.BegaymouniWaloujijou用来创建 1000 个随机的 key-value 为数据。因为代码很多，我就不写了，下面就是函数的定义，需要大家写入随机的值

        public static Foo BegaymouniWaloujijou()
        {
            return new Foo()
            {
                CurmobeKallbu = new Dictionary<string, string>()
                {
                  // 这里写入随机的值
                }
            };
        }

json

首先是使用最有名的 json 来进行序列化，安装 Nuget 第一个，点击管理nuget，然后点击浏览，现在看到的第一个是不是 json 库？如果不是，那么说明本文已经过期

在看本文的时候，如果要运行本文的代码，需要先在自己的 E 盘创建一个叫回收站的文件夹。因为我在代码会对这个文件夹写入。

            var fileInfo = new FileInfo(@"E:\回收站\xx5");

            if (!fileInfo.Exists)
            {
                var foo = Foo.BegaymouniWaloujijou();

                var stopwatch = new Stopwatch();

                stopwatch.Start();

                using (var stream = new StreamWriter(fileInfo.OpenWrite()))
                {
                    var str = JsonConvert.SerializeObject(foo, Formatting.Indented);
                    stream.Write(str);
                }

                stopwatch.Stop();

                Console.WriteLine("写入" + stopwatch.ElapsedMilliseconds);
            }
            else
            {
                var stopwatch = new Stopwatch();
                stopwatch.Start();
                var stream = fileInfo.OpenText();
                using (stream)
                {
                    var foo = JsonConvert.DeserializeObject<Foo>(stream.ReadToEnd());
                }

                stopwatch.Stop();
                Console.WriteLine("读取时间" + stopwatch.ElapsedMilliseconds);
                fileInfo.Delete();
            }

上面的代码很简单，就是使用这个方式保存

那么性能怎样？请看下面

数据的单位是毫秒，平均时间是读取 183.6 毫秒，写入165.2毫秒

ProtoBuf

这是谷歌的一个库，我安装了 protobuf-net ，然后进行序列化

         var fileInfo = new FileInfo(@"E:\回收站\xx2");
            if (!fileInfo.Exists)
            {
                var foo = Foo.BegaymouniWaloujijou();

                var stopwatch = new Stopwatch();

                stopwatch.Start();

                var stream = fileInfo.OpenWrite();

                using (stream)
                {
                    Serializer.Serialize(stream, foo);
                }

                stopwatch.Stop();

                Console.WriteLine("写入" + stopwatch.ElapsedMilliseconds);
            }
            else
            {
                var stopwatch = new Stopwatch();
                stopwatch.Start();
                var stream = fileInfo.OpenRead();
                using (stream)
                {
                    stream.Seek(0, SeekOrigin.Begin);

                    var foo = Serializer.Deserialize<Foo>(stream);
                }

                stopwatch.Stop();
                Console.WriteLine("读取时间" + stopwatch.ElapsedMilliseconds);
                fileInfo.Delete();
            }

我尝试在 ssd 和机械硬盘读写，比较两个的性能

下面是在 ssd 的读写性能，平均时间是读取 91.8 毫秒，写入 119.4 毫秒

我尝试在机械硬盘读写，平均时间是读取104.4毫秒，写入140.2毫秒

wire

这是传说中最快的序列化库，我安装了 Wire 然后使用下面的代码，运行 5 次计算读写时间

          var fileInfo = new FileInfo(@"E:\回收站\xx3");


            if (!fileInfo.Exists)
            {
                var foo = Foo.BegaymouniWaloujijou();

                var stopwatch = new Stopwatch();

                stopwatch.Start();

                var stream = fileInfo.OpenWrite();

                using (stream)
                {
                    var serializer = new Wire.Serializer();
                    serializer.Serialize(foo, stream);
                }

                stopwatch.Stop();

                Console.WriteLine("写入" + stopwatch.ElapsedMilliseconds);
            }
            else
            {
                var stopwatch = new Stopwatch();
                stopwatch.Start();
                var stream = fileInfo.OpenRead();
                using (stream)
                {
                    var serializer = new Wire.Serializer();
                    var foo = serializer.Deserialize<Foo>(stream);
                }

                stopwatch.Stop();
                Console.WriteLine("读取时间" + stopwatch.ElapsedMilliseconds);
                fileInfo.Delete();
            }

虽然小伙伴说他是最快的，但是在我的设备，平均读取125.8毫秒，写入101.2毫秒

自己写的

最后我尝试自己写了简单的序列化，因为存放的信息是key-value，我可以控制包含的字符串都是不带换行，也就是我可以一行放 value 一行放关键字。

           var fileInfo = new FileInfo(@"E:\回收站\xx7");
            if (!fileInfo.Exists)
            {
                var foo = Foo.BegaymouniWaloujijou();

                var stopwatch = new Stopwatch();

                stopwatch.Start();

                using (var stream = new StreamWriter(fileInfo.OpenWrite()))
                {
                    foreach (var temp in foo.CurmobeKallbu)
                    {
                        stream.WriteLine(temp.Key);
                        stream.WriteLine(temp.Value);
                    }
                }

                stopwatch.Stop();

                Console.WriteLine("写入" + stopwatch.ElapsedMilliseconds);
            }
            else
            {
                var stopwatch = new Stopwatch();
                stopwatch.Start();
                var stream = fileInfo.OpenText();
                using (stream)
                {
                    var str = stream.ReadToEnd().Split('\n');
                    var foo = new Foo();
                    foo.CurmobeKallbu = new Dictionary<string, string>(str.Length / 2);
                    string key = null;
                    foreach (var temp in str)
                    {
                        if (key == null)
                        {
                            key = temp;
                        }
                        else
                        {
                            foo.CurmobeKallbu.Add(key, temp);
                            key = null;
                        }
                    }
                }

                stopwatch.Stop();
                Console.WriteLine("读取时间" + stopwatch.ElapsedMilliseconds);
                fileInfo.Delete();
            }

我发现在 ssd 和在机械硬盘读写性能几乎没有相差，有时候相同程序在 ssd 运行的时间比在机械硬盘多。在我测试了自己写的程序才知道，最多的时间在序列化，读取文件的时间反而可以被忽略。使用自己写的序列化读取1毫秒，写入7.2毫秒，所以这么简单的配置文件还是自己做序列化比较快。

建议

在软件启动的时候，还有一个读取文件是加载库，如果我使用了第三方的 dll ，那么在启动的时候我就需要加载这个 dll ，但是我读取的配置文件只有不到 100 k 但是我加载的几个库都是很大。加载库的时间已经足够我自己写的序列化读取完成，需要知道，在启动程序的时候不是把所有程序的库都加载，只有在用到的时候才去读取库，读取库也是需要时间，所以程序启动的时候尽量不要引用不相关的库。