序列化测试

Posted 2021-02-13 nocanstillbb

namespace Test
{
    using System;
    using System.IO;
    using System.Text;
    using System.Xml;
    using System.Xml.Serialization;
    using Test.Share;
    using Microshaoft;
    public class Class1
    {
        static void Main(string[] args)
        {
            WebDirectory x = new WebDirectory();
            x.Name = "Microshaoft";
            WebFile y1 = new WebFile();
            y1.Name = "Microshaoft简体繁體中文";
            y1.IsReadOnly = false;
            y1.Url = "http://www.microshaoft.com";
            WebFile y2 = new WebFile();
            y2.Name = "Microshaoft中文";
            y2.Flag = FlagEnum.Value2;
            WebFile[] a = new WebFile[2];
            a[0] = y1;
            a[1] = y2;
            x.WebFiles = a;
            Console.WriteLine("Binary 序列化:");
            byte[] buffer = SerializerHelper.ObjectToBinary<WebDirectory>(x);
            Console.WriteLine("Binary 反序列化:");
            Console.WriteLine("Binary Serialize bytes Length:{0}", buffer.Length);
            WebDirectory z = SerializerHelper.BinaryToObject<WebDirectory>(buffer);
            Console.WriteLine(z.WebFiles[0].Name);
            Console.WriteLine(z.WebFiles[0].Url);
            Console.WriteLine(z.WebFiles[0].Flag);
            Console.WriteLine(z.WebFiles[1].Flag);
            Encoding e = Encoding.UTF8;
            e = Encoding.GetEncoding("gb2312");
            //e = Encoding.BigEndianUnicode;
            MemoryStream stream = new MemoryStream();
            XmlTextWriter writer = new XmlTextWriter(stream, e);
            XmlSerializer serializer = new XmlSerializer(x.GetType());
            string xml = SerializerHelper.ObjectToXml<WebDirectory>
                                                    (
                                                        x
                                                        , writer
                                                        , serializer
                                                    );
            Console.WriteLine("Xml序列化:");
            Console.WriteLine(xml);
            Console.WriteLine("Xml反序列化:");
            z = SerializerHelper.XmlToObject<WebDirectory>(xml);
            Console.WriteLine(z.WebFiles[0].Name);
            Console.WriteLine(z.WebFiles[0].Url);
            Console.WriteLine(z.WebFiles[0].Flag);
            Console.WriteLine(z.WebFiles[1].Flag);
            stream = new MemoryStream();
            buffer = e.GetPreamble();
            stream.Write(buffer, 0, buffer.Length);
            buffer = e.GetBytes(xml);
            Console.WriteLine("Xml Serialize bytes Length:{0}", buffer.Length);
            stream.Write(buffer, 0, buffer.Length);
            stream.Position = 0;
            XmlReader reader = XmlReader.Create(stream);
            while (reader.Read())
            {
                if (reader.NodeType == XmlNodeType.EndElement)
                {
                    continue;
                }
                Console.Write("NodeType{0}: NodeName:{1}", reader.NodeType, reader.Name);
                if (reader.HasValue)
                {
                    Console.Write(" NodeValue:{0}", reader.Value);
                }
                Console.WriteLine();
                if (reader.HasAttributes)
                {
                    while (reader.MoveToNextAttribute())
                    {
                        Console.WriteLine("Attribute:{0}={1}", reader.Name, reader.Value);
                    }
                }
                //Console.ReadLine();
            }
            Console.WriteLine("Hello World");
            Console.WriteLine(Environment.Version.ToString());
            Console.ReadKey();
        }
    }
}
namespace Test.Share
{
    using System;
    using System.Collections.Generic;
    using System.Xml.Serialization;
    [XmlRoot("WebDirectory")]
    [Serializable]
    public class WebDirectory
    {
        [XmlAttribute("Name")]
        public string Name;
        [XmlArrayItem("WebFile", typeof(WebFile))]
        [XmlArray("WebFiles")]
        public WebFile[] WebFiles;

        //public Dictionary<string,string> MyProperty { get; set; }
    }
    public enum FlagEnum : uint
    {
        Value1
        , Value2
    }
    [Serializable]
    public class WebFile
    {
        [XmlAttribute("Name")]
        public string Name;
        [XmlAttribute("CreateTime")]
        public DateTime CreateTime;
        [XmlAttribute("LastWriteTime")]
        [XmlIgnore()]
        public DateTime LastWriteTime;
        [XmlAttribute("Length")]
        public long Length;
        //[XmlAttribute("Url")]
        [XmlElement("Url")]
        public string Url;
        [XmlAttribute("IsReadOnly")]
        public bool IsReadOnly;
        [XmlAttribute("Flag")]
        public FlagEnum Flag;
    }
}
namespace Microshaoft
{
    using System;
    using System.IO;
    using System.Text;
    using System.Xml;
    using System.Xml.Serialization;
    using System.Runtime.Serialization.Formatters.Binary;
    public static class SerializerHelper
    {
        public static T XmlToObject<T>(string Xml)
        {
            StringReader stringReader = new StringReader(Xml);
            XmlReader xmlReader = XmlReader.Create(stringReader);
            XmlSerializer serializer = new XmlSerializer(typeof(T));
            return (T)serializer.Deserialize(xmlReader);
        }
        public static string ObjectToXml<T>
                                    (
                                        T Object
                                        , XmlTextWriter writer
                                        , XmlSerializer serializer
                                    )
        {
            serializer.Serialize(writer, Object);
            MemoryStream stream = writer.BaseStream as MemoryStream;
            byte[] bytes = stream.ToArray();
            Encoding e = EncodingHelper.IdentifyEncoding
                                            (
                                                bytes
                                                , Encoding.GetEncoding("gb2312")
                                            ///                                                , new Encoding[]
                                            ///                                                        {
                                            ///                                                            Encoding.UTF8
                                            ///                                                            , Encoding.Unicode
                                            ///                                                        }
                                            );
            byte[] buffer = e.GetPreamble();
            int offset = buffer.Length;
            buffer = new byte[bytes.Length - offset];
            Buffer.BlockCopy(bytes, offset, buffer, 0, buffer.Length);
            string s = e.GetString(buffer);
            return s;
        }
        public static string ObjectToXml<T>(T Object, Encoding e)
        {
            XmlSerializer serializer = new XmlSerializer(typeof(T));
            using (MemoryStream stream = new MemoryStream())
            {
                XmlTextWriter writer = new XmlTextWriter(stream, e);
                string s = ObjectToXml<T>
                                    (
                                        Object
                                        , writer
                                        , serializer
                                    );
                writer.Close();
                writer = null;
                return s;
            }
        }
        public static byte[] ObjectToBinary<T>
                                    (
                                        T Object
                                    )
        {
            using (MemoryStream stream = new MemoryStream())
            {
                BinaryFormatter formater = new BinaryFormatter();
                formater.Serialize(stream, Object);
                byte[] buffer = stream.ToArray();
                return buffer;
            }
        }
        public static T BinaryToObject<T>
                                    (
                                        byte[] data
                                    )
        {
            using (MemoryStream stream = new MemoryStream())
            {
                BinaryFormatter formater = new BinaryFormatter();
                stream.Write(data, 0, data.Length);
                stream.Position = 0;
                T Object = (T)formater.Deserialize(stream);
                return Object;
            }
        }
    }
}
namespace Microshaoft
{
    using System.IO;
    using System.Text;
    using System.Collections.Generic;
    public static class EncodingHelper
    {
        public static Encoding IdentifyEncoding
                                    (
                                        Stream stream
                                        , Encoding defaultEncoding
                                        , Encoding[] identifyEncodings
                                    )
        {
            byte[] data = StreamDataHelper.ReadDataToBytes(stream);
            return IdentifyEncoding
                        (
                            data
                            , defaultEncoding
                            , identifyEncodings
                        );
        }
        public static Encoding IdentifyEncoding
                                    (
                                        Stream stream
                                        , Encoding defaultEncoding
                                    )
        {
            byte[] data = StreamDataHelper.ReadDataToBytes(stream);
            return IdentifyEncoding
                        (
                            data
                            , defaultEncoding
                        );
        }
        public static Encoding IdentifyEncoding
                                    (
                                        byte[] data
                                        , Encoding defaultEncoding
                                    )
        {
            EncodingInfo[] encodingInfos = Encoding.GetEncodings();
            List<Encoding> list = new List<Encoding>();
            foreach (EncodingInfo info in encodingInfos)
            {
                Encoding e = info.GetEncoding();
                if (e.GetPreamble().Length > 0)
                {
                    list.Add(e);
                    System.Console.WriteLine(e.EncodingName);
                }
            }
            Encoding[] encodings = new Encoding[list.Count];
            list.CopyTo(encodings);
            return IdentifyEncoding
                        (
                            data
                            , defaultEncoding
                            , encodings
                        );
        }
        public static Encoding IdentifyEncoding
                                    (
                                        byte[] data
                                        , Encoding defaultEncoding
                                        , Encoding[] identifyEncodings
                                    )
        {
            Encoding encoding = defaultEncoding;
            foreach (Encoding e in identifyEncodings)
            {
                byte[] buffer = e.GetPreamble();
                int l = buffer.Length;
                if (l == 0)
                {
                    continue;
                }
                bool flag = false;
                for (int i = 0; i < l; i++)
                {
                    if (buffer[i] != data[i])
                    {
                        flag = true;
                        break;
                    }
                }
                if (flag)
                {
                    continue;
                }
                else
                {
                    encoding = e;
                }
            }
            return encoding;
        }
    }
}
namespace Microshaoft
{
    using System.IO;
    public static class StreamDataHelper
    {
        public static byte[] ReadDataToBytes(Stream stream)
        {
            byte[] buffer = new byte[64 * 1024];
            MemoryStream ms = new MemoryStream();
            int r = 0;
            int l = 0;
            long position = -1;
            if (stream.CanSeek)
            {
                position = stream.Position;
                stream.Position = 0;
            }
            while (true)
            {
                r = stream.Read(buffer, 0, buffer.Length);
                if (r > 0)
                {
                    l += r;
                    ms.Write(buffer, 0, r);
                }
                else
                {
                    break;
                }
            }
            byte[] bytes = new byte[l];
            ms.Position = 0;
            ms.Read(bytes, 0, (int)l);
            ms.Close();
            ms.Dispose();
            ms = null;
            if (position >= 0)
            {
                stream.Position = position;
            }
            return bytes;
        }
    }
}