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)
{
ServiceBusXmlMessage message = new ServiceBusXmlMessage();
MessageSecurityHeader security = new MessageSecurityHeader();
security.SenderID = "sender001";
security.Signature = "asdasdsadsa";
security.SignTimeStamp = "asdasdsa";
Router router = new Router();
router.Topic = "Topic01";
router.From = "From01";
router.FromReferenceID = "11111111111111";
router.To = new string[] { "to01", "to02", "to03" };
Encoding e = Encoding.UTF8;
e = Encoding.GetEncoding("gb2312");
MemoryStream stream = new MemoryStream();
XmlTextWriter writer = new XmlTextWriter(stream, e);
XmlSerializer serializer = new XmlSerializer(router.GetType());
string xml = SerializerHelper.ObjectToXml<Router>
(
router
, writer
, serializer
);
message.RoutersHeader = new CDATA(xml);
message.SecurityHeader = security;
SampleBody sampleBody = new SampleBody();
sampleBody.TimeStamp = "sadadsad";
sampleBody.AreaNo = "Area1";
sampleBody.ChannelNo = "CH1";
stream = new MemoryStream();
writer = new XmlTextWriter(stream, e);
serializer = new XmlSerializer(sampleBody.GetType());
xml = SerializerHelper.ObjectToXml<SampleBody>
(
sampleBody
, writer
, serializer
);
message.Body = new CDATA(xml);
stream = new MemoryStream();
writer = new XmlTextWriter(stream, e);
serializer = new XmlSerializer(message.GetType());
xml = SerializerHelper.ObjectToXml<ServiceBusXmlMessage>
(
message
, writer
, serializer
);
Console.WriteLine("Xml序列化:");
Console.WriteLine(xml);
Console.WriteLine("Xml反序列化:");
ServiceBusXmlMessage message2 = SerializerHelper.XmlToObject<ServiceBusXmlMessage>(xml);
Console.WriteLine(message2.SecurityHeader.SenderID);
Console.WriteLine("hi: " + message2.RoutersHeader.InnerSourceXml);
Console.WriteLine("hi: " + message2.RoutersHeader.InnerXml);
Console.WriteLine("body: " + message2.Body.OuterXml);
Console.WriteLine("body: " + message2.Body.InnerXml);
Router router2 = SerializerHelper.XmlToObject<Router>(message2.RoutersHeader.InnerXml);
Console.WriteLine(router2.To[0]);
SampleBody sampleBody2 = SerializerHelper.XmlToObject<SampleBody>(message2.Body.InnerXml);
Console.WriteLine(sampleBody2.AreaNo);
//Console.WriteLine("Hello World");
//Console.WriteLine(Environment.Version.ToString());
Console.ReadLine();
}
}
}
namespace Test.Share
{
using System;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;
[XmlRoot("ServiceBusXmlMessage")]
[Serializable]
public class ServiceBusXmlMessage
{
[XmlElement("Security", typeof(MessageSecurityHeader))]
public MessageSecurityHeader SecurityHeader;
[XmlElement("Routers", typeof(CDATA))]
public CDATA RoutersHeader;
[XmlElement("Body", typeof(CDATA))]
public CDATA Body;
}
[Serializable]
public class MessageSecurityHeader
{
[XmlAttribute("SenderID")]
public string SenderID;
[XmlAttribute("Signature")]
public string Signature;
[XmlAttribute("SignTimeStamp")]
public string SignTimeStamp;
}
[Serializable]
public class Router
{
[XmlAttribute("Topic")]
public string Topic;
[XmlAttribute("From")]
public string From;
[XmlAttribute("FromReferenceID")]
public string FromReferenceID;
[XmlElement("To", typeof(string))]
public string[] To;
}
[Serializable]
public class SampleBody
{
[XmlAttribute("TimeStamp")]
public string TimeStamp;
[XmlElement("AreaNo")]
public string AreaNo;
[XmlElement("ChannelNo")]
public string ChannelNo;
}
public class CDATA : IXmlSerializable
{
public CDATA()
{
}
public CDATA(string xml)
{
this._outerXml = xml;
}
private string _outerXml;
public string OuterXml
{
get
{
return _outerXml;
}
}
private string _innerXml;
public string InnerXml
{
get
{
return _innerXml;
}
}
private string _innerSourceXml;
public string InnerSourceXml
{
get
{
return _innerXml;
}
}
XmlSchema IXmlSerializable.GetSchema()
{
return null;
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
string s = reader.ReadInnerXml();
string startTag = "<![CDATA[";
string endTag = "]]>";
char[] trims = new char[] { '\r', '\n', '\t', ' ' };
s = s.Trim(trims);
if (s.StartsWith(startTag) && s.EndsWith(endTag))
{
s = s.Substring(startTag.Length, s.LastIndexOf(endTag) - startTag.Length);
}
this._innerSourceXml = s;
this._innerXml = s.Trim(trims);
}
void IXmlSerializable.WriteXml(XmlWriter writer)
{
writer.WriteCData(this._outerXml);
}
}
}
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, null);
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;
}
}
}