关于XML序列化和C#泛型的理解或者示例

Question

求教高手和大牛们，怎么去理解上面的2个东西？
    目前我无法理解上面的到底是什么，所以别人写的代码我看不懂。
比如：[Serializable]
[XmlRoot(ElementName ="DBSET")]
[XmlType(TypeName="DBSET")]
public class DbSet
{
public DbSet()
{
}

private RowsCollection m_Rows=new RowsCollection();
[XmlElement(ElementName="ROW")]//数组序列化为平面的XML序列
public  RowsCollection Rows
{
get { return m_Rows; }
set { m_Rows=value; }
}
} [Serializable]
[XmlType(TypeName="ROW")]
public class Row
{
public Row()
{
} private ColumnsCollection m_Columns=new ColumnsCollection();
[XmlElement(ElementName="COL")]//数组序列化为平面的XML序列
public  ColumnsCollection Columns
{
get { return m_Columns; }
set { m_Columns=value; }
} public void AddColumn(string strFieldName,string strFieldValue)
{
m_Columns.Add(new Column(strFieldName,strFieldValue));
}
} [Serializable]
public   class  RowsCollection:CollectionBase
{ 
   
public  RowsCollection()
{
// 
//  TODO: 在此处添加构造函数逻辑
//     
}    
public  Row  this [ int  index] 
{
get    { return  ((Row)( this .List[index]));} 
} 
 
public   int  Add(Row row) 
{   
return  List.Add(row) ;
} 
}  [Serializable]
[XmlType(TypeName="COL")]
public class Column
{
public Column()
{
}
public Column(string strFieldName,string strFieldValue)
{
m_strFieldName=strFieldName;
m_strFieldValue=strFieldValue;
} private string m_strFieldName;
[XmlAttribute(AttributeName="NAME",DataType="string")]
public string FieldName
{
get{ return m_strFieldName;}
set{ m_strFieldName=value;}
} private string m_strFieldValue;
[XmlText()]
public string FieldValue
{
get{ return m_strFieldValue;}
set{ m_strFieldValue=value;}
}
} [Serializable]
public   class  ColumnsCollection:CollectionBase
{ 
   
public  ColumnsCollection()
{
// 
//  TODO: 在此处添加构造函数逻辑
//     
}    
public  Column  this [ int  index] 
{
get    { return  ((Column)( this .List[index]));} 
} public Column this [string name]
{
get
{
Column result=null;
foreach(Column col in this)
{
if(col.FieldName==name)
{
result=col;
break;
}
}
return result;
}
}
 
public   int  Add(Column col) 
{   
return  List.Add(col) ;
} 
} 

Answer 1

Serializable，就表示这个类可以被序列化
，下面是我用到的自己写的方法，序列化后保存到文件，和从文件反序列化       public static bool Serialize<T>(T value,string filename)
        {
            try
            {
                System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bs = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                System.IO.FileStream stream = new System.IO.FileStream(filename, System.IO.FileMode.Create);
                bs.Serialize(stream, value);
                stream.Close();
                return true;
            }
            catch
            {
                return false;
            }
        }
        public static T DeSerialize<T>(string filename)
        {
            T obj;
            if (!System.IO.File.Exists(filename))
                return default(T);
            System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bs = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
            System.IO.FileStream stream = new System.IO.FileStream(filename, System.IO.FileMode.Open);
            obj = (T)bs.Deserialize(stream);
            stream.Close();
            return obj;
        }

Answer 2

在就是官网的介绍，让我头大啊
C#泛型
http://msdn.microsoft.com/zh-cn/library/ms379564(VS.80).aspx#E3AA
XML序列化
http://msdn.microsoft.com/zh-cn/library/58a18dwa(v=VS.80).aspx

Answer 3

这里面还没有泛型。你可以只关注序列化。[XmlRoot],[XmlElement]等特性就是在做类到xml的映射，你用XmlSerializer序列化成xml结构就明白了。

Answer 4

谢谢斑竹，但是如何去理解序列化？ 我目前就像看天书一样。
序列化到底是做什么的，主要起到什么作用或者是功能？
网上的资料越看越模糊，我原来是做Java的，最好能形象的解释一下。
 灰常感谢。

Answer 5

http://topic.csdn.net/u/20090622/21/df7f7b8a-61cd-4c8f-a964-0fe15377523d.html

Answer 6

因为我现在在做一个MIS中间库，就是去别人的数据库的数据进行检测，然后上传到另外一个数据库中。
 这个就是取数据的一个关键的方法，从接口继承过来的。public GeneralInfo[]  GetTasksFromMis (QueryParam[] param)
{
ArrayList al=new ArrayList();
try
{
//为调试暂时屏蔽
// if(param==null)
// return null;
// foreach(QueryParam qp in param)
// {
// //连接Web服务，读取
// Stream s = new MemoryStream();
// }

if(param==null)
{
return null;//如果取不到数据，返回空值
}
else//取到数据库进行接下来的数据操作
{
string strFile=Application.StartupPath+"\\Demo.xml";
FileStream s = File.OpenRead( strFile );//本行仅供调试用 
XmlSerializer xs=new XmlSerializer(typeof(PluginGuiZhou.DbSet));
XmlTextReader tr=new XmlTextReader(s);
PluginGuiZhou.DbSet dbset=(PluginGuiZhou.DbSet)xs.Deserialize(tr);
//遍历取到的数据集里面的数据
foreach(PluginGuiZhou.Row row in dbset.Rows)
{
GeneralInfo info=new GeneralInfo(); if(row.Columns["APP_NO"]!=null)
info.AppNo=row.Columns["APP_NO"].FieldValue; //申请编号 //if(row.Columns["CHK_NO"]!=null)
// info.CheckCode=row.Columns["CHK_NO"].FieldValue; //检定编号
if(row.Columns["CERT_ID"]!=null)
info.CertificateCode=row.Columns["CERT_ID"].FieldValue; //证书编号 if(row.Columns["BAR_CODE"]!=null)
info.BarCode=row.Columns["BAR_CODE"].FieldValue;    //条形码

if(row.Columns["IT_ID"]!=null)
info.MisID=row.Columns["IT_ID"].FieldValue; //MIS中的互感器ID

if(row.Columns["SORT_CODE"]!=null)
info.SortCode=Convert.ToInt32(row.Columns["SORT_CODE"].FieldValue); //互感器类别(01 电流/02 电压/03 组合)

if(row.Columns["ASSET_NO"]!=null)
info.DeviceCode=row.Columns["ASSET_NO"].FieldValue; //资产编号

if(row.Columns["MANUFACTURER"]!=null)
info.Manufacturer=row.Columns["MANUFACTURER"].FieldValue; //制造厂商

if(row.Columns["MADE_NO"]!=null)
info.ManufactureCode=row.Columns["MADE_NO"].FieldValue; //出厂编号

if(row.Columns["MODEL_CODE"]!=null)
info.Specification=row.Columns["MODEL_CODE"].FieldValue; //型号 if(row.Columns["RV_CODE"]!=null)
{
int nCode=Convert.ToInt32(row.Columns["RV_CODE"].FieldValue); //额定电压
switch(nCode)
{
case 1:
info.RatedVoltage=10;
break;
case 2:
info.RatedVoltage=110;
break;
case 3:
info.RatedVoltage=220;
break;
}
} if(row.Columns["RATED_FREQ_CODE"]!=null)
info.RatedFrequency=(float)Convert.ToDouble(row.Columns["RATED_FREQ_CODE"].FieldValue); //额定频率 /*if(row.Columns["PF"]!=null)
info.RatedPowerFactor=(float)Convert.ToDouble(row.Columns["PF"].FieldValue);*/ //额定功率因数
//电压互感器
if(row.Columns["TV_PRE_CODE"]!=null)
{
int nCode=Convert.ToInt32(row.Columns["TV_PRE_CODE"].FieldValue); //准确度等级
switch(nCode)
{
case 1: info.Acccuracy=1; break;
//※※准确度等级分为多少级？
/*
0.2一般用于计量
0.5一般用于测量
1级 3级 一般用于监测
3P 6P  用于保护
0.22级 用于电源
 */
}
} if(row.Columns["FST_RV_CODE"]!=null)
info.RatedInput=(float)Convert.ToDouble(row.Columns["FST_RV_CODE"].FieldValue); //额定一次电压

if(row.Columns["SND_RV_CODE"]!=null)
info.RateOutout=(float)Convert.ToDouble(row.Columns["SND_RV_CODE"].FieldValue); //额定二次电压

if(row.Columns["TV_RATED_SND_LOAD"]!=null)
{
int nCode=Convert.ToInt32(row.Columns["TV_RATED_SND_LOAD"].FieldValue); //额定负荷
switch(nCode)
{
case 1: info.RatedLoad=5F; break;
case 2: info.RatedLoad=25F; break;
case 3: info.RatedLoad=40F; break;
case 4: info.RatedLoad=15F; break;
case 5: info.RatedLoad=50F; break;
}
}
/*if(row.Columns["TV_LIGHT_LOAD"]!=null)
{
int nCode=Convert.ToInt32(row.Columns["TV_LIGHT_LOAD"].FieldValue); //轻载负荷
switch(nCode)
{
case 1: info.TVLightLoad=2.5F; break;
case 2: info.TVLightLoad=3.75F; break;
case 3: info.TVLightLoad=5F; break;
case 4: info.TVLightLoad=6.25F; break;
case 5: info.TVLightLoad=7.5F; break;
}
}*/
//电流互感器
/*if(row.Columns["TA_PRE_CODE"]!=null)
{
int nCode=Convert.ToInt32(row.Columns["TA_PRE_CODE"].FieldValue); //准确度等级
switch(nCode)
{
case 1: info.Acccuracy=1; break;
}
}*/
//if(row.Columns["FST_RC_CODE"]!=null)
// info.RatedInputCurrent=(float)Convert.ToDouble(row.Columns["FST_RC_CODE"].FieldValue); //额定一次电流)

//if(row.Columns["SND_RC_CODE"]!=null)
// info.RatedOutputCurrent=(float)Convert.ToDouble(row.Columns["SND_RC_CODE"].FieldValue); //额定二次电流)

/*if(row.Columns["TA_RATED_SND_LOAD"]!=null)
{
int nCode=Convert.ToInt32(row.Columns["TA_RATED_SND_LOAD"].FieldValue); //TA额定负荷
switch(nCode)
{
case 1: info.TARatedLoad=5F; break;
case 2: info.TARatedLoad=25F; break;
case 3: info.TARatedLoad=40F; break;
case 4: info.TARatedLoad=15F; break;
case 5: info.TARatedLoad=50F; break;
}
}*/
/*
if(row.Columns["TA_LIGHT_LOAD"]!=null)
{
int nCode=Convert.ToInt32(row.Columns["TA_LIGHT_LOAD"].FieldValue); //TA轻载负荷
switch(nCode)
{
case 1: info.TALightLoad=2.5F; break;
case 2: info.TALightLoad=3.75F; break;
case 3: info.TALightLoad=5F; break;
case 4: info.TALightLoad=6.25F; break;
case 5: info.TALightLoad=7.5F; break;
}
}*/ al.Add(info);
}
}
}
catch(Exception ex)
{
throw new Exception(ex.Message);
}

GeneralInfo[] result=new GeneralInfo[al.Count];
al.CopyTo(result);
return result;
}
里面的取数据那个部分看不懂。因为马上要过去帮别人调试，我想尽可能的理解这个功能，到时候在修改就好动手了。谢谢啊

Answer 7

关键在这：
string strFile=Application.StartupPath+"\\Demo.xml";
FileStream s = File.OpenRead( strFile );//本行仅供调试用         
XmlSerializer xs=new XmlSerializer(typeof(PluginGuiZhou.DbSet));
XmlTextReader tr=new XmlTextReader(s);
...打开文件流，把xml格式的数据反序列化成类(PluginGuiZhou.DbSet)
Xml格式如何映射，你需要看看xml里的数据。
XmlRoot不用解释了吧，Xml的根节点。
XmlElement就是其中一个节点
XmlAttribute节点上的属性
XmlText节点里的InnerText
<student class="3班">
  <name>zhangsan</name>
  <age>16</age>
</student>对应的类定义：
[XmlRoot(ElementName="student")] 
public class Student
{
   [XmlElement(ElementName="name")]
   public string Name;
   [XmlElement(ElementName="age")]
   public string Age;
   [XmlAttribute(AttributeName="class")]
   public string SClass;
}public static T XmlConvert<T>(string xml)
{
    var xmlSer = new XmlSerializer(typeof (T));
    using (var ms = new MemoryStream(Encoding.UTF8.GetBytes(xml)))
        return (T) xmlSer.Deserialize(ms);
}var student = XmlConvert<Student>("上面的Xml内容");
Console.WriteLine(student.Name);    //zhangsan
Console.WriteLine(student.Age);     //16
Console.WriteLine(student.SClass);  //3班
类里定义的名字通过ElementName,AttributeName和Xml实际的节点或属性名一一映射。
通过 XmlSerializer 反序列化成一个 Student 实例。从一种格式的文件或者数据流直接创建成类实例的过程叫反序列化，反之叫序列化。你上面就是更复杂点的组合。多个类嵌套。

Answer 8

额是草民非斑竹序列化/反序列化 主要用途：
1. 内存数据持久化，比如保存在文件里，程序退出再打开仍然能还原当时的数据。
   把内存数据保持到硬盘上。2. 跨进程，跨机器数据交互，主要是远程方法调用(分布式系统)
   机器A的内存中的某个对象 -->(序列化)[Xml/Json/Binary]--> 
   ========数据流(byte[])[Tcp/Http/Soap]===============
   机器B的内存中的某个对象 <--(反序列化)[Xml/Json/Binary]<--