XmlEncodeHelper XmlAttributeEncode/Decode XmlElementEncode/Decode

namespace Test
{
    using System;
    using System.IO;
    using System.Text;
    using System.Xml;
    using System.Xml.Serialization;
    using Microshaoft;
    public class Class1
    {
        static void Main(string[] args)
        {
            string text = "`~!@#$%&*()_+-=\t{}|[]\\://\";'<>?,./\r\n ";
            text += "～！＃￥％…＆×（）——＋·－＝｛｝｜【】＼：“”；‘’＇＜＞？，．／　";
            Console.WriteLine("orginal text: {0}", text);
            string s = XmlEncodeHelper.XmlAttributeValueEncode(text);
            Console.WriteLine("XmlAttributeValueEncode: {0}", s);
            string ss = XmlEncodeHelper.XmlAttributeValueDecode(s);
            Console.WriteLine("XmlAttributeValueDecode: {0}", ss);
            Console.WriteLine("{0}", (ss == text ? true : false));
            s = XmlEncodeHelper.XmlElementValueEncode(text);
            Console.WriteLine("XmlElementValueEncode: {0}", s);
            ss = XmlEncodeHelper.XmlElementValueDecode(s);
            Console.WriteLine("XmlElementValueDecode: {0}", ss);
            Console.WriteLine("{0}", (ss == text ? true : false));
        }
    }
}
namespace Microshaoft
{
    using System;
    using System.IO;
    using System.Text;
    using System.Xml;
    using System.Xml.Serialization;
    public static class XmlEncodeHelper
    {
        public static string XmlAttributeValueEncode
                        (
                            string text
                        )
        {
            XmlDocument document = GenerateXmlDocument(text);
            XmlNode node = document.DocumentElement.SelectSingleNode("Element");
            text = node.Attributes["EncodedAttributeValue"].InnerXml;
            return text;
        }
        public static string XmlElementValueEncode
                        (
                            string text
                        )
        {
            XmlDocument document = GenerateXmlDocument(text);
            XmlNode node = document.DocumentElement.SelectSingleNode("Element/EncodedElementValue");
            text = node.InnerXml;
            return text;
        }
        public static string XmlAttributeValueDecode(string xml)
        {
            XmlDocument document = GenerateXmlDocument("");
            XmlNode node = document.DocumentElement.SelectSingleNode("Element");
            node.Attributes["EncodedAttributeValue"].InnerXml = xml;
            string s = node.Attributes["EncodedAttributeValue"].InnerText;
            return s;
        }
        public static string XmlElementValueDecode(string xml)
        {
            XmlDocument document = GenerateXmlDocument("");
            XmlNode node = document.DocumentElement.SelectSingleNode("Element/EncodedElementValue");
            node.InnerXml = xml;
            string s = node.InnerText;
            return s;
        }
        private static XmlDocument GenerateXmlDocument(string text)
        {
            EncodedElement y = new EncodedElement();
            y.EncodedAttributeValue = text;
            y.EncodedElementValue = text;
            XmlEncoder x = new XmlEncoder();
            x.Element = y;
            Encoding e = Encoding.UTF8;
            MemoryStream stream = new MemoryStream();
            XmlTextWriter writer = new XmlTextWriter(stream, e);
            XmlSerializer serializer = new XmlSerializer(x.GetType());
            string xml = SerializerHelper.ObjectToXml<XmlEncoder>
                                                    (
                                                        x
                                                        , writer
                                                        , serializer
                                                    );
            XmlDocument document = new XmlDocument();
            document.LoadXml(xml);
            return document;
        }
    }
    [XmlRoot("XmlEncoder")]
    [Serializable]
    public class XmlEncoder
    {
        [XmlElement("Element")]
        public EncodedElement Element;
    }
    [Serializable]
    public class EncodedElement
    {
        [XmlAttribute("EncodedAttributeValue")]
        public string EncodedAttributeValue;
        [XmlElement("EncodedElementValue")]
        public string EncodedElementValue;
    }
}


namespace Microshaoft
{
    using System;
    using System.IO;
    using System.Text;
    using System.Xml;
    using System.Xml.Serialization;
    using System.Runtime.Serialization.Formatters.Binary;
    using System.Runtime.Serialization.Formatters.Soap;
    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;
        }
    }
}