C#中将一个XML格式的字符串序列化成实体类 报DateTime类型错误 请高手指点一下

Posted 2023-04-25

估计是DataSet或者DataTable输出的XML。。。默认情况下输出的时间格式不对。输出XML前要转换下 参考技术A 贴出代码，看看？

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 用于简化序列化和反序列化操作 。
/// 作者：朱伟 [e-mail]
/// 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)
方法吧。
祝你好运！
是否可以解决您的问题？