C#序列化一个类成xml
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C#序列化一个类成xml相关的知识,希望对你有一定的参考价值。
我要序列化成下面一段xml
<xml>
<jiedianx>123</jiedianx>
<jiediany>
<jiedianz>123</jiedianz>
</jiediany>
</xml>
那么这个被序列化的类该怎么写??
添加以下帮助类,然后调用很简单
string resutl=XmlUtil.Serializer(typeof(Depart), dp);
Depart是实体类名
dp是实例化之后的实体
using System;using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.IO;
using System.Xml.Serialization;
using System.Xml;
namespace WFXML
public class XmlUtil
#region 反序列化
/// <summary>
/// 反序列化
/// </summary>
/// <param name="type">类型</param>
/// <param name="xml">XML字符串</param>
/// <returns></returns>
public static object Deserialize(Type type, string xml)
try
using (StringReader sr = new StringReader(xml))
XmlSerializer xmldes = new XmlSerializer(type);
return xmldes.Deserialize(sr);
catch (Exception e)
return null;
/// <summary>
/// 反序列化
/// </summary>
/// <param name="type"></param>
/// <param name="xml"></param>
/// <returns></returns>
public static object Deserialize(Type type, Stream stream)
XmlSerializer xmldes = new XmlSerializer(type);
return xmldes.Deserialize(stream);
#endregion
#region 序列化XML文件
/// <summary>
/// 序列化XML文件
/// </summary>
/// <param name="type">类型</param>
/// <param name="obj">对象</param>
/// <returns></returns>
public static string Serializer(Type type, object obj)
MemoryStream Stream = new MemoryStream();
//创建序列化对象
XmlSerializer xml = new XmlSerializer(type);
try
//序列化对象
xml.Serialize(Stream, obj);
catch (InvalidOperationException)
throw;
Stream.Position = 0;
StreamReader sr = new StreamReader(Stream);
string str = sr.ReadToEnd();
return str;
#endregion
#region 将XML转换为DATATABLE
/// <summary>
/// 将XML转换为DATATABLE
/// </summary>
/// <param name="FileURL"></param>
/// <returns></returns>
public static DataTable XmlAnalysisArray()
try
string FileURL = System.Configuration.ConfigurationManager.AppSettings["Client"].ToString();
DataSet ds = new DataSet();
ds.ReadXml(FileURL);
return ds.Tables[0];
catch (Exception ex)
System.Web.HttpContext.Current.Response.Write(ex.Message.ToString());
return null;
/// <summary>
/// 将XML转换为DATATABLE
/// </summary>
/// <param name="FileURL"></param>
/// <returns></returns>
public static DataTable XmlAnalysisArray(string FileURL)
try
DataSet ds = new DataSet();
ds.ReadXml(FileURL);
return ds.Tables[0];
catch (Exception ex)
System.Web.HttpContext.Current.Response.Write(ex.Message.ToString());
return null;
#endregion
#region 获取对应XML节点的值
/// <summary>
/// 摘要:获取对应XML节点的值
/// </summary>
/// <param name="stringRoot">XML节点的标记</param>
/// <returns>返回获取对应XML节点的值</returns>
public static string XmlAnalysis(string stringRoot, string xml)
if (stringRoot.Equals("") == false)
try
XmlDocument XmlLoad = new XmlDocument();
XmlLoad.LoadXml(xml);
return XmlLoad.DocumentElement.SelectSingleNode(stringRoot).InnerXml.Trim();
catch (Exception ex)
return "";
#endregion
参考技术A class jiedian
pulic string jiedianxget;set;
public jiediany jiediany get;set;
class jiediany
public string jiedianzget;set;
本回答被提问者采纳 参考技术B 你直接序列化成string不就行了,呵呵,给你个类吧
/****************************************
* 作者:张江松
* 创始时间:2008-5-29
* 功能:
*
* 修改人:
* 修改时间:
* 描述:
****************************************/
namespace MultiMedia.Common
using System;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Soap;
/// <summary>
/// SerializeHelper 用于简化序列化和反序列化操作 。
/// 作者:朱伟 sky.zhuwei@163.com
/// 2004.05.12
/// </summary>
public static class SerializeHelper
#region BinaryFormatter
#region SerializeObject
public static byte[] SerializeObject(object obj) //obj 可以是数组
IFormatter formatter = new BinaryFormatter();
MemoryStream memoryStream = new MemoryStream();//此种情况下,mem_stream的缓冲区大小是可变的
formatter.Serialize(memoryStream, obj);
byte[] buff = memoryStream.ToArray();
memoryStream.Close();
return buff;
public static void SerializeObject(object obj, ref byte[] buff, int offset) //obj 可以是数组
byte[] rude_buff = SerializeHelper.SerializeObject(obj);
for (int i = 0; i < rude_buff.Length; i++)
buff[offset + i] = rude_buff[i];
#endregion
#region DeserializeBytes
public static object DeserializeBytes(byte[] buff, int index, int count)
IFormatter formatter = new BinaryFormatter();
MemoryStream stream = new MemoryStream(buff, index, count);
object obj = formatter.Deserialize(stream);
stream.Close();
return obj;
#endregion
#endregion
#region SoapFormatter
#region SerializeObjectToString
/// <summary>
/// SerializeObjectToString 将对象序列化为SOAP XML 格式。
/// 如果要将对象转化为简洁的xml格式,请使用ESBasic.Persistence.SimpleXmlConverter类。
/// </summary>
public static string SerializeObjectToString(object obj)
IFormatter formatter = new SoapFormatter();
MemoryStream stream = new MemoryStream();
formatter.Serialize(stream, obj);
stream.Position = 0;
StreamReader reader = new StreamReader(stream);
string res = reader.ReadToEnd();
stream.Close();
return res;
#endregion
#region DeserializeString
public static object DeserializeString(string str,System.Text.Encoding ecnoding)
byte[] buff = ecnoding.GetBytes(str);
IFormatter formatter = new SoapFormatter();
MemoryStream stream = new MemoryStream(buff, 0, buff.Length);
object obj = formatter.Deserialize(stream);
stream.Close();
return obj;
#endregion
#endregion
#region XmlSerializer
#region XmlObject
public static string XmlObject(object obj)
XmlSerializer xmlSerializer = new XmlSerializer(obj.GetType());
MemoryStream stream = new MemoryStream();
xmlSerializer.Serialize(stream, obj);
stream.Position = 0;
StreamReader reader = new StreamReader(stream);
string res = reader.ReadToEnd();
stream.Close();
return res;
#endregion
#region ObjectXml
public static T ObjectXml<T>(string str, System.Text.Encoding ecnoding)
return (T)SerializeHelper.ObjectXml(str, typeof(T), ecnoding);
public static object ObjectXml(string str, Type targetType, System.Text.Encoding ecnoding)
byte[] buff = ecnoding.GetBytes(str);
XmlSerializer xmlSerializer = new XmlSerializer(targetType);
MemoryStream stream = new MemoryStream(buff, 0, buff.Length);
object obj = xmlSerializer.Deserialize(stream);
stream.Close();
return obj;
#endregion
#endregion
#region SaveToFile
/// <summary>
/// SaveToFile 将对象的二进制序列化后保存到文件。
/// </summary>
public static void SaveToFile(object obj, string filePath)
FileStream stream = new FileStream(filePath, FileMode.CreateNew);
IFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, obj);
stream.Flush();
stream.Close();
#endregion
#region ReadFromFile
/// <summary>
/// ReadFromFile 从文件读取二进制反序列化为对象。
/// </summary>
public static object ReadFromFile(string filePath)
byte[] buff = FileHelper.ReadFileReturnBytes(filePath);
return SerializeHelper.DeserializeBytes(buff, 0, buff.Length);
#endregion
/// <summary>
/// 序列化类
/// </summary>
public static class Serializer
/// <summary>
/// Static Constructor is used to set the CanBinarySerialize value only once for the given security policy
/// </summary>
static Serializer()
SecurityPermission sp = new SecurityPermission( SecurityPermissionFlag.SerializationFormatter );
try
sp.Demand();
CanBinarySerialize = true;
catch ( SecurityException )
CanBinarySerialize = false;
/// <summary>
/// Readonly value indicating if Binary Serialization (using BinaryFormatter) is allowed
/// </summary>
public static readonly bool CanBinarySerialize;
/// <summary>
/// Converts a .NET object to a byte array. Before the conversion happens, a check with
/// Serializer.CanBinarySerialize will be made
/// </summary>
/// <param name="objectToConvert">Object to convert</param>
/// <returns>A byte arry representing the object paramter. Null will be return if CanBinarySerialize is false</returns>
public static byte[] ConvertToBytes( object objectToConvert )
byte[] byteArray = null;
if ( CanBinarySerialize )
BinaryFormatter binaryFormatter = new BinaryFormatter();
using ( MemoryStream ms = new MemoryStream() )
binaryFormatter.Serialize( ms, objectToConvert );
// Set the position of the MemoryStream back to 0
//
ms.Position = 0;
// Read in the byte array
//
byteArray = new Byte[ ms.Length ];
ms.Read( byteArray, 0, byteArray.Length );
ms.Close();
return byteArray;
/// <summary>
/// Saves an object to disk as a binary file.
/// </summary>
/// <param name="objectToSave">Object to Save</param>
/// <param name="path">Location of the file</param>
/// <returns>true if the save was succesful.</returns>
public static bool SaveAsBinary( object objectToSave, string path )
if ( objectToSave != null && CanBinarySerialize )
byte[] ba = ConvertToBytes( objectToSave );
if ( ba != null )
using ( FileStream fs = new FileStream( path, FileMode.OpenOrCreate, FileAccess.Write ) )
using ( BinaryWriter bw = new BinaryWriter( fs ) )
bw.Write( ba );
return true;
return false;
/// <summary>
/// Converts a .NET object to a string of XML. The object must be marked as Serializable or an exception
/// will be thrown.
/// </summary>
/// <param name="objectToConvert">Object to convert</param>
/// <returns>A xml string represting the object parameter. The return value will be null of the object is null</returns>
public static string ConvertToString( object objectToConvert )
string xml = null;
if ( objectToConvert != null )
//we need the type to serialize
Type t = objectToConvert.GetType();
XmlSerializer ser = new XmlSerializer( t );
//will hold the xml
using ( StringWriter writer = new StringWriter( CultureInfo.InvariantCulture ) )
ser.Serialize( writer, objectToConvert );
xml = writer.ToString();
writer.Close();
return xml;
public static void SaveAsXML( object objectToConvert, string path )
if ( objectToConvert != null )
//we need the type to serialize
Type t = objectToConvert.GetType();
XmlSerializer ser = new XmlSerializer( t );
//will hold the xml
using ( StreamWriter writer = new StreamWriter( path ) )
ser.Serialize( writer, objectToConvert );
writer.Close();
/// <summary>
/// Converts a byte array to a .NET object. You will need to cast this object back to its expected type.
/// If the array is null or empty, it will return null.
/// </summary>
/// <param name="byteArray">An array of bytes represeting a .NET object</param>
/// <returns>The byte array converted to an object or null if the value of byteArray is null or empty</returns>
public static object ConvertToObject( byte[] byteArray )
object convertedObject = null;
if ( CanBinarySerialize && byteArray != null && byteArray.Length > 0 )
BinaryFormatter binaryFormatter = new BinaryFormatter();
using ( MemoryStream ms = new MemoryStream() )
ms.Write( byteArray, 0, byteArray.Length );
// Set the memory stream position to the beginning of the stream
//
ms.Position = 0;
if ( byteArray.Length > 4 )
convertedObject = binaryFormatter.Deserialize( ms );
ms.Close();
return convertedObject;
/// <summary>
/// Converts a string of xml to the supplied object type.
/// </summary>
/// <param name="xml">Xml representing a .NET object</param>
/// <param name="objectType">The type of object which the xml represents</param>
/// <returns>A instance of object or null if the value of xml is null or empty</returns>
public static object ConvertToObject( XmlNode node, Type objectType )
object convertedObject = null;
if ( node != null )
using ( StringReader reader = new StringReader( node.OuterXml ) )
XmlSerializer ser = new XmlSerializer( objectType );
convertedObject = ser.Deserialize( reader );
reader.Close();
return convertedObject;
public static object ConvertFileToObject( string path, Type objectType )
object convertedObject = null;
if ( path != null && path.Length > 0 )
using ( FileStream fs = new FileStream( path, FileMode.Open, FileAccess.Read ) )
XmlSerializer ser = new XmlSerializer( objectType );
convertedObject = ser.Deserialize( fs );
fs.Close();
return convertedObject;
/// <summary>
/// Converts a string of xml to the supplied object type.
/// </summary>
/// <param name="xml">Xml representing a .NET object</param>
/// <param name="objectType">The type of object which the xml represents</param>
/// <returns>A instance of object or null if the value of xml is null or empty</returns>
public static object ConvertToObject( string xml, Type objectType )
object convertedObject = null;
if ( !string.IsNullOrEmpty( xml ) )
using ( StringReader reader = new StringReader( xml ) )
XmlSerializer ser = new XmlSerializer( objectType );
convertedObject = ser.Deserialize( reader );
reader.Close();
return convertedObject;
public static object LoadBinaryFile( string path )
if ( !File.Exists( path ) )
return null;
using ( FileStream fs = new FileStream( path, FileMode.Open, FileAccess.Read ) )
BinaryReader br = new BinaryReader( fs );
byte[] ba = new byte[ fs.Length ];
br.Read( ba, 0, ( int )fs.Length );
return ConvertToObject( ba );
/// <summary>
/// Creates a NameValueCollection from two string. The first contains the key pattern and the second contains the values
/// spaced according to the kys
/// </summary>
/// <param name="keys">Keys for the namevalue collection</param>
/// <param name="values">Values for the namevalue collection</param>
/// <returns>A NVC populated based on the keys and vaules</returns>
/// <example>
/// string keys = "key1:S:0:3:key2:S:3:2:";
/// string values = "12345";
/// This would result in a NameValueCollection with two keys (Key1 and Key2) with the values 123 and 45
/// </example>
public static NameValueCollection ConvertToNameValueCollection( string keys, string values )
NameValueCollection nvc = new NameValueCollection();
if ( keys != null && values != null && keys.Length > 0 && values.Length > 0 )
char[] splitter = new char[ 1 ] ':' ;
string[] keyNames = keys.Split( splitter );
for ( int i = 0; i < ( keyNames.Length / 4 ); i++ )
int start = int.Parse( keyNames[ ( i * 4 ) + 2 ], CultureInfo.InvariantCulture );
int len = int.Parse( keyNames[ ( i * 4 ) + 3 ], CultureInfo.InvariantCulture );
string key = keyNames[ i * 4 ];
//Future version will support more complex types
if ( ( ( keyNames[ ( i * 4 ) + 1 ] == "S" ) && ( start >= 0 ) ) && ( len > 0 ) && ( values.Length >= ( start + len ) ) )
nvc[ key ] = values.Substring( start, len );
return nvc;
/// <summary>
/// Creates a the keys and values strings for the simple serialization based on a NameValueCollection
/// </summary>
/// <param name="nvc">NameValueCollection to convert</param>
/// <param name="keys">the ref string will contain the keys based on the key format</param>
/// <param name="values">the ref string will contain all the values of the namevaluecollection</param>
public static void ConvertFromNameValueCollection( NameValueCollection nvc, ref string keys, ref string values )
if ( nvc == null || nvc.Count == 0 )
return;
StringBuilder sbKey = new StringBuilder();
StringBuilder sbValue = new StringBuilder();
int index = 0;
foreach ( string key in nvc.AllKeys )
if ( key.IndexOf( ':' ) != -1 )
throw new ArgumentException( "ExtendedAttributes Key can not contain the character \":\"" );
string v = nvc[ key ];
if ( !string.IsNullOrEmpty( v ) )
sbKey.AppendFormat( "0:S:1:2:", key, index, v.Length );
sbValue.Append( v );
index += v.Length;
keys = sbKey.ToString();
values = sbValue.ToString();
用里面的 public static string SerializeObjectToString(object obj)
方法吧。
祝你好运!
是否可以解决您的问题?
以上是关于C#序列化一个类成xml的主要内容,如果未能解决你的问题,请参考以下文章