Xml/Binary SerializerHelper and XmlReader read xml node/attribute on foward-only sequential

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());
}
}
}
namespace Test.Share
{
using System;
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 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;
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;
}
}
}