.NET অবজেক্টগুলিকে সিরিয়ালাইজ এবং ডিসাইরিয়ালাইজ করার দ্রুততম উপায়

Question

.NET অবজেক্টগুলিকে সিরিয়ালাইজ এবং ডিসরিয়ালাইজ করার দ্রুততম উপায় আমি সন্ধান করছি। আমার এখন পর্যন্ত যা আছে তা এখানে:

public class TD
{
    public List<CT> CTs { get; set; }
    public List<TE> TEs { get; set; }
    public string Code { get; set; }
    public string Message { get; set; }
    public DateTime StartDate { get; set; }
    public DateTime EndDate { get; set; }

    public static string Serialize(List<TD> tData)
    {
        var serializer = new XmlSerializer(typeof(List<TD>));

        TextWriter writer = new StringWriter();
        serializer.Serialize(writer, tData);

        return writer.ToString();
    }

    public static List<TD> Deserialize(string tData)
    {
        var serializer = new XmlSerializer(typeof(List<TD>));

        TextReader reader = new StringReader(tData);

        return (List<TD>)serializer.Deserialize(reader);
    }        
}

Comments

পারফরম্যান্স বা কোড ফুট মুদ্রণ?

— ulrichb

আপনি কি আমাকে জিজ্ঞাসা করছেন আমার কি পারফরম্যান্স ডেটা বা কোড দরকার?

— আরন

তিনি জিজ্ঞাসা করছেন, "দ্রুততম উপায়ে", আপনি পারফরম্যান্সের দিক থেকে বা কোড পদচিহ্নের দিক থেকে বোঝাচ্ছেন কি না। BinaryFormatterকোড এবং বাস্তবায়নের ক্ষেত্রে অত্যন্ত দ্রুত, তবে মার্কের মতো সমাধানটি একটি বেঞ্চমার্কে দ্রুত সম্পাদন করবে।

— কোডি গ্রে

ঠিক আছে, আমি দেখছি, আমি পারফরম্যান্সের দিক দিয়ে

— বুঝি

অনেক লিঙ্ক আছে সেখানে। এর মধ্যে একটি: ব্লগস.এমএসএনএন

— ইউসেসফএম

Answer 1

এখানে আপনার মডেল (উদ্ভাবিত CTএবং TE) প্রোটোবুফ-নেট ব্যবহার করে (এখনও ব্যবহারের সক্ষমতা ধরে রাখা XmlSerializer, যা দরকারী হতে পারে - বিশেষত মাইগ্রেশনের জন্য); আমি বিনীতভাবে (প্রমাণ প্রচুর সঙ্গে যদি আপনি এটি প্রয়োজন) জমা যে এই হল দ্রুততম (অথবা অবশ্যই দ্রুততম এক) .NET সাধারণ উদ্দেশ্য serializer।

আপনার যদি স্ট্রিং দরকার হয় তবে বাইনারিটি কেবল বেস -৪৪ এনকোড করুন।

[XmlType]
public class CT {
    [XmlElement(Order = 1)]
    public int Foo { get; set; }
}
[XmlType]
public class TE {
    [XmlElement(Order = 1)]
    public int Bar { get; set; }
}
[XmlType]
public class TD {
    [XmlElement(Order=1)]
    public List<CT> CTs { get; set; }
    [XmlElement(Order=2)]
    public List<TE> TEs { get; set; }
    [XmlElement(Order = 3)]
    public string Code { get; set; }
    [XmlElement(Order = 4)]
    public string Message { get; set; }
    [XmlElement(Order = 5)]
    public DateTime StartDate { get; set; }
    [XmlElement(Order = 6)]
    public DateTime EndDate { get; set; }

    public static byte[] Serialize(List<TD> tData) {
        using (var ms = new MemoryStream()) {
            ProtoBuf.Serializer.Serialize(ms, tData);
            return ms.ToArray();
        }            
    }

    public static List<TD> Deserialize(byte[] tData) {
        using (var ms = new MemoryStream(tData)) {
            return ProtoBuf.Serializer.Deserialize<List<TD>>(ms);
        }
    }
}

Comments

জিডে মার্ক, আপনার করা প্রোটোকল-বাফারদের কাজটি পছন্দ করুন এবং আমি জানি এই পোস্টটি প্রায় 5 বছরের পুরনো তবে এখানে একটি উত্তরে উদ্ধৃত নেটসিরিয়ালাইজারের (বিনোজ) মেট্রিক রয়েছে যা আপনার বাস্তবায়নটি দ্রুততম নয় indic এটি কি ন্যায্য বিবৃতি / বিজ্ঞাপন বা কোনও বাণিজ্য বন্ধ রয়েছে? ধন্যবাদ

— জেরেমি থম্পসন

ঠিক আছে আমি এখন দেখতে পাচ্ছি, নেটারিশাইজেশন কেবল একই সংস্করণে কাজ করে যেখানে আমি সংস্করণ সহনীয় সিরিয়ালাইজেশন খুঁজছি

— জেরেমি থম্পসন

যে কেউ এই দ্রুত বলে মনে করে সে অবশ্যই কিছু ধূমপান করবে, এটি প্রচুর ক্ষেত্রে যথেষ্ট দ্রুত হতে পারে এবং এটি অন্যান্য প্রচুর সিরিয়ালগুলির চেয়ে দ্রুততর হতে পারে, তবে ম্যানুয়ালি বিশ্লেষণের তুলনায় এটি কি দ্রুততর? আমার godশ্বর না।

— বজরকিসেকে

@ বারজার সি কে সিরিয়ালাইজারগুলি অন্তর্নিহিতভাবে আরও কিছুটা জড়িত, কারণ লোকেরা তাদের নিজের পা গুলি চালানো রোধ করতে অনেক কিছুই করার প্রয়োজন (বিশেষত তারা সংস্করণগুলি পুনরুক্ত করে তোলে); বেশিরভাগ লোকেরা সিরিয়ালাইজেশন কোডটি ডিবাগিংয়ে তাদের জীবন ব্যয় করতে চায় না, সুতরাং: একটি ভাল সিরিয়ালাইজার - নিখুঁতভাবে নিখুঁতভাবে প্রয়োগ করা সংস্করণ-অসহিষ্ণু ম্যানুয়াল প্রয়োগের চেয়ে ধীর - বেশিরভাগ মানুষের পক্ষে সাধারণত সমঝোতা

— মার্ক গ্রাভেল

@ বারজারকেকে আমি দৃ strongly়ভাবে একমত নই; এটি বেশিরভাগ লোকের জন্য দূর থেকে কার্যকরও নয়। এরপরে কী - প্রতিদিন আমাদের নিজস্ব সংগ্রহগুলি লিখছেন? না: এই জিনিসগুলি এমনকি যুক্তিসঙ্গতভাবে করা খুব কঠিন । নিশ্চিত, আপনি আসলে খুব দ্রুততম আউটপুট প্রয়োজন: আপনি আপনার হাত ময়লা পেতে আছে চলুন - কিন্তু অধিকাংশ মানুষের জন্য, এই কাজ একটি হবে সত্যিই তাদের সময় খারাপ বর্জ্য। সেরা এটি তাদের অনেক বেশি সময় নিতে পারে। আরও সম্ভবত, তাদের কোডটি বগি, অবিশ্বাস্য এবং সম্ভবত উপলব্ধ গ্রন্থাগারগুলি ব্যবহারের চেয়ে ধীর হবে। বেশিরভাগ লোকদের তাদের অ্যাপের প্রয়োজনের বিষয়ে মনোনিবেশ করা উচিত , এই মিনিটটি নয়।

— মার্ক গ্র্যাভেল

Answer 2

এই পোস্টে আমার দ্বারা তৈরি বিভিন্ন ফর্ম্যাটগুলির মধ্যে একটি বোধগম্য তুলনা- https://maxondev.com/serialization-performance-compistance-c-net-formats-frameworks-xmldatacontractserializer-xmlserializer-binaryformatter-json-newtonsoft-servicestack-text/

পোস্ট থেকে মাত্র একটি নমুনা-

Comments

এটা গতি নয়। এটা আস্তে এটি লিঙ্কযুক্ত নিবন্ধে "ছোট আরও ভাল" বলে।

— তৈমুর নুরিয়াসভ

@ টিমুরনিউরিয়াসভ, অপারেশনটি করতে সময়টি হয়েছিল

— ম্যাক্সিম

সুতরাং আপনি বলেন বাইনারি সবচেয়ে ধীর? আমি তাই মনে করি না! আমার ধারণা এটি সঠিকভাবে গতিকে বোঝায়, সময় নয়।

— জাভিদ

বাইনারি সবচেয়ে ধীর হয়। নিজে চেষ্টা করুন। তবে আমি বলব এটি সবচেয়ে সহজ, কারণ

— পলিমারফিক আইটেমগুলি

নিচে ... বাইনারি আমার পরীক্ষার সময়ে @Kamarey চেহারা পথ দ্রুত অন্যদের তুলনায়।

— জেরেমি হলোভাকস

Answer 3

এতে আগ্রহী হওয়ায় আমি প্রস্তাবিত পদ্ধতিগুলি আমার নিকটতম "আপেল থেকে আপেল" পরীক্ষার মাধ্যমে পরীক্ষা করার সিদ্ধান্ত নিয়েছি। আমি নিম্নলিখিত কোড সহ একটি কনসোল অ্যাপ্লিকেশন লিখেছি:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;

namespace SerializationTests
{
    class Program
    {
        static void Main(string[] args)
        {
            var count = 100000;
            var rnd = new Random(DateTime.UtcNow.GetHashCode());
            Console.WriteLine("Generating {0} arrays of data...", count);
            var arrays = new List<int[]>();
            for (int i = 0; i < count; i++)
            {
                var elements = rnd.Next(1, 100);
                var array = new int[elements];
                for (int j = 0; j < elements; j++)
                {
                    array[j] = rnd.Next();
                }   
                arrays.Add(array);
            }
            Console.WriteLine("Test data generated.");
            var stopWatch = new Stopwatch();

            Console.WriteLine("Testing BinarySerializer...");
            var binarySerializer = new BinarySerializer();
            var binarySerialized = new List<byte[]>();
            var binaryDeserialized = new List<int[]>();

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var array in arrays)
            {
                binarySerialized.Add(binarySerializer.Serialize(array));
            }
            stopWatch.Stop();
            Console.WriteLine("BinaryFormatter: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var serialized in binarySerialized)
            {
                binaryDeserialized.Add(binarySerializer.Deserialize<int[]>(serialized));
            }
            stopWatch.Stop();
            Console.WriteLine("BinaryFormatter: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);


            Console.WriteLine();
            Console.WriteLine("Testing ProtoBuf serializer...");
            var protobufSerializer = new ProtoBufSerializer();
            var protobufSerialized = new List<byte[]>();
            var protobufDeserialized = new List<int[]>();

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var array in arrays)
            {
                protobufSerialized.Add(protobufSerializer.Serialize(array));
            }
            stopWatch.Stop();
            Console.WriteLine("ProtoBuf: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var serialized in protobufSerialized)
            {
                protobufDeserialized.Add(protobufSerializer.Deserialize<int[]>(serialized));
            }
            stopWatch.Stop();
            Console.WriteLine("ProtoBuf: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            Console.WriteLine();
            Console.WriteLine("Testing NetSerializer serializer...");
            var netSerializerSerializer = new ProtoBufSerializer();
            var netSerializerSerialized = new List<byte[]>();
            var netSerializerDeserialized = new List<int[]>();

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var array in arrays)
            {
                netSerializerSerialized.Add(netSerializerSerializer.Serialize(array));
            }
            stopWatch.Stop();
            Console.WriteLine("NetSerializer: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var serialized in netSerializerSerialized)
            {
                netSerializerDeserialized.Add(netSerializerSerializer.Deserialize<int[]>(serialized));
            }
            stopWatch.Stop();
            Console.WriteLine("NetSerializer: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            Console.WriteLine("Press any key to end.");
            Console.ReadKey();
        }

        public class BinarySerializer
        {
            private static readonly BinaryFormatter Formatter = new BinaryFormatter();

            public byte[] Serialize(object toSerialize)
            {
                using (var stream = new MemoryStream())
                {
                    Formatter.Serialize(stream, toSerialize);
                    return stream.ToArray();
                }
            }

            public T Deserialize<T>(byte[] serialized)
            {
                using (var stream = new MemoryStream(serialized))
                {
                    var result = (T)Formatter.Deserialize(stream);
                    return result;
                }
            }
        }

        public class ProtoBufSerializer
        {
            public byte[] Serialize(object toSerialize)
            {
                using (var stream = new MemoryStream())
                {
                    ProtoBuf.Serializer.Serialize(stream, toSerialize);
                    return stream.ToArray();
                }
            }

            public T Deserialize<T>(byte[] serialized)
            {
                using (var stream = new MemoryStream(serialized))
                {
                    var result = ProtoBuf.Serializer.Deserialize<T>(stream);
                    return result;
                }
            }
        }

        public class NetSerializer
        {
            private static readonly NetSerializer Serializer = new NetSerializer();
            public byte[] Serialize(object toSerialize)
            {
                return Serializer.Serialize(toSerialize);
            }

            public T Deserialize<T>(byte[] serialized)
            {
                return Serializer.Deserialize<T>(serialized);
            }
        }
    }
}

ফলাফল আমাকে অবাক করে; একাধিকবার চালানোর সময় এগুলি সুসংগত ছিল:

Generating 100000 arrays of data...
Test data generated.
Testing BinarySerializer...
BinaryFormatter: Serializing took 336.8392ms.
BinaryFormatter: Deserializing took 208.7527ms.

Testing ProtoBuf serializer...
ProtoBuf: Serializing took 2284.3827ms.
ProtoBuf: Deserializing took 2201.8072ms.

Testing NetSerializer serializer...
NetSerializer: Serializing took 2139.5424ms.
NetSerializer: Deserializing took 2113.7296ms.
Press any key to end.

এই ফলাফলগুলি সংগ্রহ করে, আমি সিদ্ধান্ত নিয়েছি যে প্রোটোফুফ বা নেটসারিয়ালাইজার বৃহত্তর অবজেক্টগুলির সাথে আরও ভাল পারফরম্যান্স করেছে কিনা। আমি সংগ্রহের সংখ্যা 10,000 টি বস্তুতে পরিবর্তিত করেছি, তবে অ্যারের আকার 1-100 এর পরিবর্তে 1-10,000 এ বাড়িয়েছি। ফলাফলগুলি আরও চূড়ান্ত বলে মনে হয়েছিল:

Generating 10000 arrays of data...
Test data generated.
Testing BinarySerializer...
BinaryFormatter: Serializing took 285.8356ms.
BinaryFormatter: Deserializing took 206.0906ms.

Testing ProtoBuf serializer...
ProtoBuf: Serializing took 10693.3848ms.
ProtoBuf: Deserializing took 5988.5993ms.

Testing NetSerializer serializer...
NetSerializer: Serializing took 9017.5785ms.
NetSerializer: Deserializing took 5978.7203ms.
Press any key to end.

সুতরাং আমার উপসংহারটি হ'ল: এমন ঘটনাও ঘটতে পারে যেখানে প্রোটোফুফ এবং নেটসারিয়ালাইজারের পক্ষে উপযুক্ত উপযুক্ত, তবে কমপক্ষে অপেক্ষাকৃত সাধারণ বস্তুর জন্য কাঁচা পারফরম্যান্সের ক্ষেত্রে ... বাইনারি ফর্ম্যাটর কমপক্ষে একটি মাত্রার অর্ডার দ্বারা উল্লেখযোগ্যভাবে আরও পারফরম্যান্ট।

ওয়াইএমএমভি

Comments

সম্ভবত বাইনারিফর্মেটর অ্যারে সহ সত্যিই দ্রুত।

— বেহরোজ

এটি সম্ভব ... তবে উল্লিখিত শর্তাদি অনুসারে ফলাফল ছিল নাটকীয়। এখানে পাঠ্যটি কেবল হতে পারে, বিশ্বাস করুন না যে একটি পদ্ধতি সকল পরিস্থিতিতে সর্বাধিক পারফরম্যান্ট। পরীক্ষা এবং মানদণ্ড সর্বদা আলোকিত করে।

— জেরেমি হলোভা্যাকস

সি ++ অবজেক্টে সিরিয়ালকরণ প্রায় 100 গুণ দ্রুত!

— মারিও এম

খুব আকর্ষণীয়! প্রত্যেকে প্রোটোবুফকে দ্রুততম বলে দাবি করেছিল তবে এটি স্পষ্টভাবে দেখায় যে এটি বেদনাদায়ক ধীরে ধীরে। আমি আমার বিনারনসায়ারালাইজারকে এখানে dotnetfiddle.net/gOqQ7p মিশ্রণে যুক্ত করেছি - এটি বাইনারি ফরম্যাটারের চেয়ে প্রায় দ্বিগুণ দ্রুত, এটি ইতিমধ্যে অ্যারেগুলির সাথে খুব দ্রুত।

— জ্যাচ দেখেছেন

Answer 4

প্রোটোবুফ খুব দ্রুত is

এই সিস্টেমের কর্মক্ষমতা এবং একটি বাস্তবায়ন সম্পর্কিত গভীরতার তথ্যের জন্য http://code.google.com/p/protobuf-net/wiki/Performance দেখুন ।

Comments

প্রোটোবুফ ব্যবহারে কোনও ত্রুটি আছে কি?

— রবার্ট জ্যাপিসেন

আপনাকে আপনার অবজেক্টগুলি টিকিয়ে রাখতে হবে। প্রোটোবুফ ক্ষেত্রের নাম এবং ধরণের সিরিয়ালাইজারদের মতো সঞ্চয় করে না, তবে সেগুলি আপনার প্রকৃত প্রকারের থেকে নিন। লক্ষ্যযুক্ত ফাইলগুলি অনেক ছোট হওয়ার এটি অন্যতম কারণ। ডকুমেন্টেশন এই সমস্ত ব্যাখ্যা করে। আমি এটি কিছু সময়ের জন্য ব্যবহার করে আসছি এবং যদি আপনার দ্রুত (ডি) সিরিয়ালাইজেশন এবং ছোট টার্গেট ফাইলের প্রয়োজন হয় তবে প্রোটোবুফ সত্যিই যাবার উপায়।

— পিটার ভ্যান জিনকেল

উত্তরের সাথে যুক্ত করতে # # তে প্রোটবুট ব্যবহার করে কোনও সম্পূর্ণ উত্স কোডের নমুনা?

— কিকিনেট

এটি তাত্পর্যপূর্ণ

— জ্যাচ

@ জ্যাচসউ আপনি কেবল পূর্ণসংখ্যার অ্যারেগুলি (যেমন আপনার উদাহরণ) নিয়ে কাজ করছেন তবে এটি তত দ্রুত নয়, তবে খুব কম লোকই কেবল পূর্ণসংখ্যাকে সিরিয়ালাইজ করছে। যখন আপনি প্রচুর সদস্যের সাথে নেস্টেড জটিল ধরণের মোকাবেলা শুরু করেন আপনি গতির সুবিধাগুলি দেখতে পান (বা কমপক্ষে আমিও করি)।

— matt.rothmeyer

Answer 5

তবুও বাইরে আরও একটি সিরিয়ালাইজার দাবি করেছে যে সুপার ফাস্ট বলে দাবি নেটসারিয়ালাইজার ।

তাদের সাইটে প্রদত্ত ডেটা প্রোটোবুফের ওপরে 2x - 4x এর পারফরম্যান্স দেখায় , আমি এটি নিজে চেষ্টা করে দেখিনি, তবে আপনি যদি বিভিন্ন বিকল্পের মূল্যায়ন করেন তবে এটিও চেষ্টা করে দেখুন

Comments

আমি আমার অ্যাপ্লিকেশনে নেটসারিয়ালাইজারটি চেষ্টা করেছি এবং এটি আশ্চর্যের সাথে কাজ করে। এটা চেষ্টা করার যোগ্য।

— গ্যালেন

নেটসিরিয়ালাইজার "ব্যবহারকারী" অবজেক্টগুলিকে সিরিয়ালাইজ করার পক্ষে উপযুক্ত নয় যেখানে গ্রন্থাগারটি জানেন না কী কী প্রকারগুলি শুরু করতে হবে, বা এমনকি ব্যবহারকারীকে তাদের বস্তুগুলিকে সিরিয়ালযোগ্য হিসাবে চিহ্নিত করতে বাধ্য করার বিকল্প রয়েছে।

— জ্যাচ

Answer 6

.Net এর সাথে অন্তর্ভুক্ত বাইনারি সিরিয়ালাইজারটি এক্সএমএলসিরাইজারের চেয়ে দ্রুত হওয়া উচিত। বা প্রোটোবুফ, জসন, এর জন্য অন্য সিরিয়ালাইজার ...

তবে তাদের কয়েকটির জন্য আপনাকে অ্যাট্রিবিউট যুক্ত করতে হবে, বা মেটাডেটা যুক্ত করার জন্য অন্য কোনও উপায়ে। উদাহরণস্বরূপ, প্রোটোফুফ অভ্যন্তরীণভাবে সংখ্যার সম্পত্তি আইডি ব্যবহার করে এবং ম্যাপিংটি কোনওরকমভাবে আলাদা ব্যবস্থার দ্বারা সংরক্ষণ করা দরকার। সংস্করণ কোনও সিরিয়ালাইজারের সাথে তুচ্ছ নয়।

Comments

হ্যাঁ, এটি সত্যিই খুব দ্রুত এবং এটি এক্সএমএল এর চেয়ে অনেক বেশি মামলা / প্রকারগুলি পরিচালনা করে les

— লেপি

Answer 7

আমি উপরের কোডগুলিতে বাগগুলি সরিয়েছি এবং নীচে ফলাফল পেয়েছি: এছাড়াও নেট সিরিয়ালাইজার কীভাবে আপনার সিরিয়াল তৈরি করছেন, কী ধরণের সামঞ্জস্যতা বা পারফরম্যান্স পার্থক্য সম্ভাব্যতা তৈরি করতে পারে তা নিবন্ধভুক্ত করার জন্য আপনাকে কীভাবে প্রয়োজন তা নিশ্চিত করে আমি নিশ্চিত নই।

Generating 100000 arrays of data...
Test data generated.
Testing BinarySerializer...
BinaryFormatter: Serializing took 508.9773ms.
BinaryFormatter: Deserializing took 371.8499ms.

Testing ProtoBuf serializer...
ProtoBuf: Serializing took 3280.9185ms.
ProtoBuf: Deserializing took 3190.7899ms.

Testing NetSerializer serializer...
NetSerializer: Serializing took 427.1241ms.
NetSerializer: Deserializing took 78.954ms.
Press any key to end.

সংশোধিত কোড

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;

namespace SerializationTests
{
    class Program
    {
        static void Main(string[] args)
        {
            var count = 100000;
            var rnd = new Random((int)DateTime.UtcNow.Ticks & 0xFF);
            Console.WriteLine("Generating {0} arrays of data...", count);
            var arrays = new List<int[]>();
            for (int i = 0; i < count; i++)
            {
                var elements = rnd.Next(1, 100);
                var array = new int[elements];
                for (int j = 0; j < elements; j++)
                {
                    array[j] = rnd.Next();
                }
                arrays.Add(array);
            }
            Console.WriteLine("Test data generated.");
            var stopWatch = new Stopwatch();

            Console.WriteLine("Testing BinarySerializer...");
            var binarySerializer = new BinarySerializer();
            var binarySerialized = new List<byte[]>();
            var binaryDeserialized = new List<int[]>();

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var array in arrays)
            {
                binarySerialized.Add(binarySerializer.Serialize(array));
            }
            stopWatch.Stop();
            Console.WriteLine("BinaryFormatter: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var serialized in binarySerialized)
            {
                binaryDeserialized.Add(binarySerializer.Deserialize<int[]>(serialized));
            }
            stopWatch.Stop();
            Console.WriteLine("BinaryFormatter: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);


            Console.WriteLine();
            Console.WriteLine("Testing ProtoBuf serializer...");
            var protobufSerializer = new ProtoBufSerializer();
            var protobufSerialized = new List<byte[]>();
            var protobufDeserialized = new List<int[]>();

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var array in arrays)
            {
                protobufSerialized.Add(protobufSerializer.Serialize(array));
            }
            stopWatch.Stop();
            Console.WriteLine("ProtoBuf: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var serialized in protobufSerialized)
            {
                protobufDeserialized.Add(protobufSerializer.Deserialize<int[]>(serialized));
            }
            stopWatch.Stop();
            Console.WriteLine("ProtoBuf: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            Console.WriteLine();
            Console.WriteLine("Testing NetSerializer serializer...");
            var netSerializerSerialized = new List<byte[]>();
            var netSerializerDeserialized = new List<int[]>();

            stopWatch.Reset();
            stopWatch.Start();
            var netSerializerSerializer = new NS();
            foreach (var array in arrays)
            {
                netSerializerSerialized.Add(netSerializerSerializer.Serialize(array));
            }
            stopWatch.Stop();
            Console.WriteLine("NetSerializer: Serializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            stopWatch.Reset();
            stopWatch.Start();
            foreach (var serialized in netSerializerSerialized)
            {
                netSerializerDeserialized.Add(netSerializerSerializer.Deserialize<int[]>(serialized));
            }
            stopWatch.Stop();
            Console.WriteLine("NetSerializer: Deserializing took {0}ms.", stopWatch.Elapsed.TotalMilliseconds);

            Console.WriteLine("Press any key to end.");
            Console.ReadKey();
        }

        public class BinarySerializer
        {
            private static readonly BinaryFormatter Formatter = new BinaryFormatter();

            public byte[] Serialize(object toSerialize)
            {
                using (var stream = new MemoryStream())
                {
                    Formatter.Serialize(stream, toSerialize);
                    return stream.ToArray();
                }
            }

            public T Deserialize<T>(byte[] serialized)
            {
                using (var stream = new MemoryStream(serialized))
                {
                    var result = (T)Formatter.Deserialize(stream);
                    return result;
                }
            }
        }

        public class ProtoBufSerializer
        {
            public byte[] Serialize(object toSerialize)
            {
                using (var stream = new MemoryStream())
                {
                    ProtoBuf.Serializer.Serialize(stream, toSerialize);
                    return stream.ToArray();
                }
            }

            public T Deserialize<T>(byte[] serialized)
            {
                using (var stream = new MemoryStream(serialized))
                {
                    var result = ProtoBuf.Serializer.Deserialize<T>(stream);
                    return result;
                }
            }
        }

        public class NS
        {
            NetSerializer.Serializer Serializer = new NetSerializer.Serializer(new Type[] { typeof(int), typeof(int[]) });

            public byte[] Serialize(object toSerialize)
            {
                using (var stream = new MemoryStream())
                {
                    Serializer.Serialize(stream, toSerialize);
                    return stream.ToArray();
                }
            }

            public T Deserialize<T>(byte[] serialized)
            {
                using (var stream = new MemoryStream(serialized))
                {
                    Serializer.Deserialize(stream, out var result);
                    return (T)result;
                }
            }
        }
    }
}

Comments

আপনি কোন বাগগুলি উল্লেখ করছেন?

— জেরেমি হলোভ্যাকস

Answer 8

আপনি সালারবয়েস সিরিয়ালাইজার চেষ্টা করতে পারেন যার একটি ভাল পারফরম্যান্স রয়েছে। এর ফোকাস পে-লোড আকারের উপর তবে এটি ভাল পারফরম্যান্সও দেয়।

গিথুব পৃষ্ঠায় মানদণ্ড রয়েছে যদি আপনি নিজেরাই ফলাফলগুলি দেখতে এবং তুলনা করতে চান।

https://github.com/salarcode/Oois

Answer 9

আমি আপনার ক্লাসগুলিকে সিজিবিআর জেনারেটরে খাওয়ানোর স্বাধীনতা নিয়েছি ।কারণ এটি প্রাথমিক পর্যায়ে এটি DateTimeএখনও সমর্থন করে না , তাই আমি কেবল এটি দীর্ঘ দিয়ে প্রতিস্থাপন করেছি। উত্পন্ন সিরিয়ালাইজেশন কোডটি দেখতে এরকম দেখাচ্ছে:

public int Size
{
    get 
    { 
        var size = 24;
        // Add size for collections and strings
        size += Cts == null ? 0 : Cts.Count * 4;
        size += Tes == null ? 0 : Tes.Count * 4;
        size += Code == null ? 0 : Code.Length;
        size += Message == null ? 0 : Message.Length;

        return size;              
    }
}

public byte[] ToBytes(byte[] bytes, ref int index)
{
    if (index + Size > bytes.Length)
        throw new ArgumentOutOfRangeException("index", "Object does not fit in array");

    // Convert Cts
    // Two bytes length information for each dimension
    GeneratorByteConverter.Include((ushort)(Cts == null ? 0 : Cts.Count), bytes, ref index);
    if (Cts != null)
    {
        for(var i = 0; i < Cts.Count; i++)
        {
            var value = Cts[i];
            value.ToBytes(bytes, ref index);
        }
    }
    // Convert Tes
    // Two bytes length information for each dimension
    GeneratorByteConverter.Include((ushort)(Tes == null ? 0 : Tes.Count), bytes, ref index);
    if (Tes != null)
    {
        for(var i = 0; i < Tes.Count; i++)
        {
            var value = Tes[i];
            value.ToBytes(bytes, ref index);
        }
    }
    // Convert Code
    GeneratorByteConverter.Include(Code, bytes, ref index);
    // Convert Message
    GeneratorByteConverter.Include(Message, bytes, ref index);
    // Convert StartDate
    GeneratorByteConverter.Include(StartDate.ToBinary(), bytes, ref index);
    // Convert EndDate
    GeneratorByteConverter.Include(EndDate.ToBinary(), bytes, ref index);
    return bytes;
}

public Td FromBytes(byte[] bytes, ref int index)
{
    // Read Cts
    var ctsLength = GeneratorByteConverter.ToUInt16(bytes, ref index);
    var tempCts = new List<Ct>(ctsLength);
    for (var i = 0; i < ctsLength; i++)
    {
        var value = new Ct().FromBytes(bytes, ref index);
        tempCts.Add(value);
    }
    Cts = tempCts;
    // Read Tes
    var tesLength = GeneratorByteConverter.ToUInt16(bytes, ref index);
    var tempTes = new List<Te>(tesLength);
    for (var i = 0; i < tesLength; i++)
    {
        var value = new Te().FromBytes(bytes, ref index);
        tempTes.Add(value);
    }
    Tes = tempTes;
    // Read Code
    Code = GeneratorByteConverter.GetString(bytes, ref index);
    // Read Message
    Message = GeneratorByteConverter.GetString(bytes, ref index);
    // Read StartDate
    StartDate = DateTime.FromBinary(GeneratorByteConverter.ToInt64(bytes, ref index));
    // Read EndDate
    EndDate = DateTime.FromBinary(GeneratorByteConverter.ToInt64(bytes, ref index));

    return this;
}

আমি এর মতো নমুনা বস্তুর একটি তালিকা তৈরি করেছি:

var objects = new List<Td>();
for (int i = 0; i < 1000; i++)
{
    var obj = new Td
    {
        Message = "Hello my friend",
        Code = "Some code that can be put here",
        StartDate = DateTime.Now.AddDays(-7),
        EndDate = DateTime.Now.AddDays(2),
        Cts = new List<Ct>(),
        Tes = new List<Te>()
    };
    for (int j = 0; j < 10; j++)
    {
        obj.Cts.Add(new Ct { Foo = i * j });
        obj.Tes.Add(new Te { Bar = i + j });
    }
    objects.Add(obj);
}

Releaseবিল্ড ইন আমার মেশিনে ফলাফল :

var watch = new Stopwatch();
watch.Start();
var bytes = BinarySerializer.SerializeMany(objects);
watch.Stop();

আকার: 149000 বাইট

সময়: 2.059ms 3.13ms

সম্পাদনা করুন: সিজিবিআর 0.4.3 দিয়ে শুরু করে বাইনারি সিরিয়ালাইজার ডেটটাইম সমর্থন করে। দুর্ভাগ্যক্রমে DateTime.ToBinaryপদ্ধতিটি অত্যন্ত ধীর। আমি তাড়াতাড়ি কিছুটা দ্রুত এটির সাথে প্রতিস্থাপন করব।

সম্পাদনা 2: ইউটিসি ব্যবহারের সময় অনুরোধ DateTimeকরে ToUniversalTime()পারফরম্যান্সটি পুনরুদ্ধার হয় এবং 1.669ms এ ঘড়ি থাকে ।