主程序进行序列化生成xml文件，和反序列化得到xml文件中某个节点的属性

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Xml;
    6. using System.Xml.Serialization;
    7. using System.IO;
    9. namespace TrackGeoInfo
    10. {
    11.     class Program
    12.     {
    13.         static void Main(string[] args)
    14.         {
    15.             Serialize();//序列化
    16.             //DeSerialize();//反序列化
    18.         }
    19.         public static void Serialize()
    20.         {
    21.             ////测试保存TrackPiece
    22.             //TrackPiece t = new TrackPiece(120, 120, 200, 22, 33);
    23.             //try
    24.             //{
    25.             //    FileStream fs = new FileStream("C:\\Users\\18333\\Desktop\\serialiable.xml", FileMode.Create);
    26.             //    XmlSerializer xs = new XmlSerializer(typeof(TrackPiece));
    27.             //    xs.Serialize(fs, t);
    28.             //}
    29.             //catch (Exception ex)
    30.             //{
    31.             //    Console.WriteLine(ex.Message);
    32.             //}
    33.             //Console.WriteLine("序列化成功！");
    34.             //Console.ReadKey();
    36.             ////测试Track
    37.             //Track t = new Track(2, 2, 2, 2, 2, 2, 2, 2, "s", "dd");
    38.             //try
    39.             //{
    40.             //    FileStream fs = new FileStream("C:\\Users\\18333\\Desktop\\serialiable.xml", FileMode.Create);
    41.             //    //XmlSerializer xs = new XmlSerializer(typeof(TrackPiece));
    42.             //    XmlSerializer xs = new XmlSerializer(typeof(Track));
    43.             //    xs.Serialize(fs, t);
    44.             //}
    45.             //catch (Exception ex)
    46.             //{
    47.             //    Console.WriteLine(ex.Message);
    48.             //}
    49.             //Console.WriteLine("序列化成功！");
    50.             //Console.ReadKey();
    54.             //测试TrackGIS
    55.             //TrackPiece[] trackPieces = new TrackPiece[] {new TrackPiece(2, 2, 2, 2, 3),new TrackPiece(3,3,3,3,2) };
    56.             //TrackGIS t = new TrackGIS(trackPieces);
    57.             TrackPiece tp = new TrackPiece(2, 2, 2, 2, 3);
    58.             TrackPiece tp2 = new TrackPiece(3, 3, 3, 3, 2);
    59.             TrackPiece[] trackPieces = new TrackPiece[] { tp, tp2 };
    60.             TrackGIS t = new TrackGIS(trackPieces);
    61.             try
    62.             {
    63.                 FileStream fs = new FileStream("C:\\Users\\18333\\Desktop\\serialiable.xml", FileMode.Create);
    64.                 //XmlSerializer xs = new XmlSerializer(typeof(TrackPiece));
    65.                 XmlSerializer xs = new XmlSerializer(typeof(TrackGIS));
    66.                 xs.Serialize(fs, t);
    67.             }
    68.             catch (Exception ex)
    69.             {
    70.                 Console.WriteLine(ex.ToString());
    71.                 Console.WriteLine(ex.Message);
    72.             }
    73.             Console.WriteLine("序列化成功！");
    74.             Console.ReadKey();
    76.         }
    79.         public static void DeSerialize()
    80.         {
    81.             try
    82.             {
    83.                 //测试TrackPiece
    84.                 //FileStream fs = new FileStream("C:\\Users\\18333\\Desktop\\TrackPiece.xml",FileMode.Open,FileAccess.Read);
    85.                 //XmlSerializer xs = new XmlSerializer(typeof(TrackPiece));
    86.                 //TrackPiece t = (TrackPiece)xs.Deserialize(fs);
    87.                 //Console.WriteLine(t.DeltaPos+"\r\n"+t.DeltaLon);
    89.                 ////测试Track
    90.                 //FileStream fs = new FileStream("C:\\Users\\18333\\Desktop\\Track.xml", FileMode.Open, FileAccess.Read);
    91.                 //XmlSerializer xs = new XmlSerializer(typeof(Track));
    92.                 //Track t = (Track)xs.Deserialize(fs);
    93.                 //Console.WriteLine(t.StartAddress + "\r\n" + t.EndAddress);
    95.                 ////测试TrackGIS
    96.                 //FileStream fs = new FileStream("C:\\Users\\18333\\Desktop\\Serialiable.xml", FileMode.Open, FileAccess.Read);
    97.                 //XmlSerializer xs = new XmlSerializer(typeof(TrackGIS));
    98.                 //TrackGIS t = (TrackGIS)xs.Deserialize(fs);
    99.                 //foreach (TrackPiece a in t.TrackPieces)
    100.                 //{
    101.                 //    Console.WriteLine(a.DeltaLat + "\r\n" + a.DeltaLon);
    102.                 //}
    104.             }
    105.             catch(Exception ex)
    106.             {
    107.                 Console.WriteLine(ex.Message);
    108.             }
    109.             Console.Read();
    110.             Console.ReadKey();
    111.         }
    112.     }
    113. }

    依据UML类里写的
    是这个文件

    地图管理数据思维导图

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Xml.Serialization;
    6. using System.ComponentModel;
    7. using System.Xml;
    9. namespace TrackGeoInfo
    10. {
    11.     [Serializable]
    12.     [XmlRoot("TrackInfo")]
    13.     public class TrackInfo
    14.     {
    15.         private TrackHeadInfo trackHeadInfo;
    16.         //private TrackFileProperty trackFileProperty;//轨道地理数据信息头
    17.         //private Track[] tracks;
    18.         private TrackGIS trackGIS;
    20.         public TrackInfo()
    21.         {
    22.             trackHeadInfo = null;
    23.             trackGIS = null;
    25.         }
    26.         public TrackInfo(TrackHeadInfo th,TrackGIS tg)
    27.         {
    28.             trackHeadInfo = th;
    29.             trackGIS = tg;
    30.         }
    31.         //[XmlElement("TrackFileProperty")]
    32.         //public TrackFileProperty TrackFileProperty { get { return trackFileProperty; } set { trackFileProperty = value; } }
    34.         [XmlElement("TrackGIS")]
    35.         public TrackGIS TrackGIS { get {return trackGIS; } set {trackGIS=value; } }
    37.         //[XmlArray("Tracks"),XmlArrayItem("Track") ]
    38.         //public Track[] Tracks { get { return tracks; } set { tracks = value; } }
    40.     }
    42.     [XmlRoot("TrackHeadInfo")]
    43.     public class TrackHeadInfo
    44.     {
    45.         private TrackFileProperty trackFileProperty;//轨道地理数据信息头
    46.         private Track[] tracks;
    47.         public TrackHeadInfo()
    48.         {
    49.             trackFileProperty = null;
    50.             tracks = null;
    51.         }
    52.         public TrackHeadInfo(TrackFileProperty tf,Track[] ts)
    53.         {
    54.             trackFileProperty = tf;
    55.             tracks = ts;
    57.         }
    58.         [XmlElement("TrackFileProperty")]
    59.         public TrackFileProperty TrackFileProperty { get { return trackFileProperty; } set { trackFileProperty = value; } }
    61.         [XmlArray("Tracks"), XmlArrayItem("Track")]
    62.         public Track[] Tracks { get { return tracks; } set { tracks = value; } }
    63.     }
    65.     [XmlRoot("TrackFileProperty")]
    66.     public class TrackFileProperty
    67.     {
    68.         private byte fileType;//文件类型固定为1
    69.         private byte fileStructVersion;//文件结构版本
    70.         private byte fileDataVersion;//文件数据版本
    71.         private UInt16 stationNum;//车站编号
    72.         private byte trackCount;//轨道个数
    73.         //private Track[] tracks;//轨道
    75.         public TrackFileProperty()
    76.         {
    77.             fileType = 0;
    78.             fileStructVersion = 0;
    79.             fileDataVersion = 0;
    80.             stationNum = 0;
    81.             trackCount = 0;
    82.         }
    83.         public TrackFileProperty(byte ft,byte fsv,byte fdv,UInt16 sn,byte tc,Track[] ts)
    84.         {
    85.             fileType = ft;
    86.             fileStructVersion = fsv;
    87.             fileDataVersion = fdv;
    88.             stationNum = sn;
    89.             trackCount = tc;
    90.            // tracks = ts;
    91.         }
    93.         [XmlElement("FileType")]
    94.         public byte FileType { get { return fileType; } set { fileType = value; } }
    95.         [XmlElement("FileStructVersion")]
    96.         public byte FileStructVersion { get {return fileStructVersion; } set { fileStructVersion = value; } }
    97.         [XmlElement("FileDataVersion")]
    98.         public byte FileDataVersion { get {return fileDataVersion; } set { fileDataVersion = value; } }
    99.         [XmlElement("StationNum")]
    100.         public UInt16 StationNum { get {return stationNum; } set {stationNum=value; } }
    102.         [XmlElement("TrackCount")]
    103.         public byte TrackCount { get {return trackCount; } set {trackCount=value; } }
    105.         //[XmlArray("Tracks"),XmlArrayItem("Track")]
    106.         //public Track[] Tracks { get {return tracks; } set {tracks=value; } }
    107.     }
    110.     //????????????????????????????????????????????TrackID怎么设置
    111.     [XmlRoot("TrackGIS")]
    112.     public class TrackGIS
    113.     {
    114.         //private byte trackID;
    115.         private TrackPiece[] trackPieces;//轨道片记录数据
    116.         public TrackGIS()
    117.         {
    118.            // trackID = 2;
    119.             trackPieces = new TrackPiece[2];
    121.         }
    123.         public TrackGIS(TrackPiece[] tp)
    124.         {
    125.             trackPieces = tp;
    126.         }
    128.         //[XmlElement("TrackID")]
    129.         //public byte TrackID { get {return trackID; } set {trackID=value; } }
    131.         [XmlArray("TrackID"),XmlArrayItem("TrackPiece")]
    132.         public TrackPiece[] TrackPieces { get {return trackPieces; } set {trackPieces=value; } }
    134.     }
    136.     [XmlRoot("Track")]
    137.     public class Track
    138.     {
    139.         //字段
    140.         //轨道编号，单位无符号数1-255
    141.         private byte trackID;
    142.         //轨道特性
    143.         private int trackType;
    144.         //轨道特性名称
    145.         private string trackTypeName;
    146.         //起始位置，单位厘米，固定为0
    147.         private uint startMileage;
    148.         //起始纬度，单位毫秒
    149.         private int startLat;
    150.         //起始经度，单位毫秒
    151.         private int startLon;
    152.         //结束位置，单位厘米
    153.         private uint endMileage;
    154.         //结束纬度，单位毫秒
    155.         private int endLat;
    156.         //结束经度，单位毫秒
    157.         private int endLon;
    158.         //第一个轨道片的字节偏移
    159.         private string startAddress;
    160.         //最后一个轨道片的字节偏移，文件开始地址到当前轨道的最后一个轨道片记录点起始地址的字节偏移
    161.         private string endAddress;
    162.         public Track()
    163.         {
    164.             trackID = 0;
    165.             trackType = 0;
    166.             //trackTypeName = null;
    167.             startMileage = 0;
    168.             startLat = 0;
    169.             startLon = 0;
    170.             endMileage = 0;
    171.             endLat = 0;
    172.             endLon = 0;
    173.             startAddress = null;
    174.             endAddress = null;
    175.         }
    177.         public Track(byte ti, int ty, uint sm, int sLat,int sLon, uint em,int eLat,int eLon,string sA,string eA)
    178.         {
    179.             trackID = ti;
    180.             trackType = ty;
    181.             startMileage = sm;
    182.             startLat = sLat;
    183.             startLon = sLon;
    184.             endMileage = em;
    185.             endLat = eLat;
    186.             endLon = eLon;
    187.             startAddress = sA;
    188.             endAddress = eA;
    190.         }
    191.          enum tracktype : int
    192.         {
    193.             单线正线 = 1,
    194.             上行正线 = 2,
    195.             下行正线 = 3,
    196.             侧线 = 4,
    197.             其他 = 5
    198.         }
    200.         /// <summary>
    201.         /// 通过轨道特性索引得到轨道名称
    202.         /// </summary>
    203.         /// <param name="key"></param>
    204.         /// <returns></returns>
    205.         private string GetEnumNameByKey(int key)
    206.         {
    207.             return Enum.GetName(typeof(tracktype), key);
    208.         }
    210.         [XmlElement("TrackID")]
    211.         public byte TrackID { get { return trackID; } set { trackID = value; } }
    212.         //轨道特性，1-单线正线，2-上行正线，3-下行正线，4-侧线，5-其他
    213.         [XmlElement("TrackType")]
    214.         public int TrackType { get { return trackType; } set { trackType = value; } }
    216.         [XmlElement("StartMileage")]
    217.         public uint StartMileage { get { return startMileage; } set { startMileage = value; } }
    219.         [XmlElement("StartLat")]
    220.         public int StartLat { get { return startLat; } set { startLat = value; } }
    221.         [XmlElement("StartLon")]
    222.         public int StartLon { get { return startLon; } set { startLon = value; } }
    224.         [XmlElement("EndMileage")]
    225.         public uint EndMileage { get { return endMileage; } set { endMileage = value; } }
    227.         [XmlElement("EndLat")]
    228.         public int EndLat { get { return endLat; } set { endLat = value; } }
    230.         [XmlElement("EndLon")]
    231.         public int EndLon { get { return endLon; } set { endLon = value; } }
    233.         [XmlElement("StartAddress")]
    234.         public string StartAddress { get { return startAddress; } set { startAddress = value; } }
    236.         [XmlElement("EndAddress")]
    237.         public string EndAddress { get { return endAddress; } set { endAddress = value; } }
    239.         public string TrackTypeName
    240.         { get { return trackTypeName; } set { trackTypeName = value; } }
    242.     }
    244.     [XmlRoot("TrackPiece")]
    245.     public class TrackPiece
    246.     {
    247.         private uint deltaPos;//位置增量，厘米，
    248.         private int deltaLat;//纬度增量，毫秒，该轨道起始纬度到该轨道片记录点纬度的增量
    249.         private int deltaLon;//经度增量，单位毫秒，
    250.         private short deltaHeading;//增量航向角，
    251.         private int adjacentTrack;//邻近轨道，1-是，0-否
    252.         public enum adjacentTrackType
    253.         {
    254.             是 = 1,
    255.             否 = 0
    256.         }
    257.         private string GetEnumNameByKey(int key)
    258.         {
    259.             return Enum.GetName(typeof(adjacentTrackType), key);
    260.         }
    262.         public TrackPiece()
    263.         {
    264.             deltaPos = 0;
    265.             deltaLat = 0;
    266.             deltaLon = 0;
    267.             deltaHeading = 0;
    268.             adjacentTrack = 0;
    270.         }
    272.         public TrackPiece(uint dPos ,int dLat,int dLon,short dH,int aT)
    273.         {
    274.             deltaPos = dPos;
    275.             deltaLat = dLat;
    276.             deltaLon = dLon;
    277.             deltaHeading = dH;
    278.             adjacentTrack = aT;
    280.         }
    281.         [XmlElement("DeltaPos")]
    282.         public uint DeltaPos { get { return deltaPos; } set { deltaPos = value; } }
    283.         [XmlElement("DeltaLat")]
    284.         public int DeltaLat { get { return deltaLat; } set { deltaLat = value; } }
    285.         [XmlElement("DeltaLon")]
    286.         public int DeltaLon { get { return deltaLon; } set { deltaLon = value; } }
    287.         [XmlElement("DeltaHeading")]
    288.         public short DeltaHeading { get { return deltaHeading; } set { deltaHeading = value; } }
    289.         [XmlElement("AdjacentTrack")]
    290.         public int AdjacentTrack { get { return adjacentTrack; } set { adjacentTrack = value; } }
    292.     }
    294. }

    第二版：生成的文件有些不同

    1. using System;
    2. using System.Collections.Generic;
    3. using System.Linq;
    4. using System.Text;
    5. using System.Xml.Serialization;
    6. using System.ComponentModel;
    7. using System.Xml;
    9. namespace TrackGeoInfo
    10. {
    11.     [Serializable]
    12.     [XmlRoot("TrackInfo")]
    13.     public class TrackInfo
    14.     {
    15.         private TrackHeadInfo trackHeadInfo;
    16.         //private TrackFileProperty trackFileProperty;//轨道地理数据信息头
    17.         //private Track[] tracks;
    18.         private TrackGIS trackGIS;
    20.         public TrackInfo()
    21.         {
    22.             trackHeadInfo = null;
    23.             trackGIS = null;
    25.         }
    26.         public TrackInfo(TrackHeadInfo th,TrackGIS tg)
    27.         {
    28.             trackHeadInfo = th;
    29.             trackGIS = tg;
    30.         }
    31.         //[XmlElement("TrackFileProperty")]
    32.         //public TrackFileProperty TrackFileProperty { get { return trackFileProperty; } set { trackFileProperty = value; } }
    33.         [XmlElement("TrackHeadInfo")]
    34.         public TrackHeadInfo TrackHeadInfo { get {return trackHeadInfo; } set {trackHeadInfo=value; } }
    36.         [XmlElement("TrackGIS")]
    37.         public TrackGIS TrackGIS { get {return trackGIS; } set {trackGIS=value; } }
    39.         //[XmlArray("Tracks"),XmlArrayItem("Track") ]
    40.         //public Track[] Tracks { get { return tracks; } set { tracks = value; } }
    42.     }
    44.     [XmlRoot("TrackHeadInfo")]
    45.     public class TrackHeadInfo
    46.     {
    47.         private TrackFileProperty trackFileProperty;//轨道地理数据信息头
    48.         //private Track[] tracks;
    49.         private List<Track> tracks;
    50.         public TrackHeadInfo()
    51.         {
    52.             trackFileProperty = null;
    53.             tracks = null;
    54.         }
    55.         public TrackHeadInfo(TrackFileProperty tf,/*Track[] ts*/List<Track> ts)
    56.         {
    57.             trackFileProperty = tf;
    58.             tracks = ts;
    60.         }
    61.         [XmlElement("TrackFileProperty")]
    62.         public TrackFileProperty TrackFileProperty { get { return trackFileProperty; } set { trackFileProperty = value; } }
    64.         //[XmlArray("Tracks"), XmlArrayItem("Track")]
    65.         //public Track[] Tracks { get { return tracks; } set { tracks = value; } }
    67.         [XmlArray("Tracks"),XmlArrayItem("Track")]
    68.         public List<Track> Tracks { get {return tracks; } set {tracks=value; } }
    69.     }
    71.     [XmlRoot("TrackFileProperty")]
    72.     public class TrackFileProperty
    73.     {
    74.         private byte fileType;//文件类型固定为1
    75.         private byte fileStructVersion;//文件结构版本
    76.         private byte fileDataVersion;//文件数据版本
    77.         private UInt16 stationNum;//车站编号
    78.         private byte trackCount;//轨道个数
    79.         //private Track[] tracks;//轨道
    80.         //private List<Track> tracks;
    82.         public TrackFileProperty()
    83.         {
    84.             fileType = 0;
    85.             fileStructVersion = 0;
    86.             fileDataVersion = 0;
    87.             stationNum = 0;
    88.             trackCount = 0;
    89.         }
    90.         public TrackFileProperty(byte ft,byte fsv,byte fdv,UInt16 sn,byte tc,Track[] ts)
    91.         {
    92.             fileType = ft;
    93.             fileStructVersion = fsv;
    94.             fileDataVersion = fdv;
    95.             stationNum = sn;
    96.             trackCount = tc;
    97.            // tracks = ts;
    98.         }
    100.         [XmlElement("FileType")]
    101.         public byte FileType { get { return fileType; } set { fileType = value; } }
    102.         [XmlElement("FileStructVersion")]
    103.         public byte FileStructVersion { get {return fileStructVersion; } set { fileStructVersion = value; } }
    104.         [XmlElement("FileDataVersion")]
    105.         public byte FileDataVersion { get {return fileDataVersion; } set { fileDataVersion = value; } }
    106.         [XmlElement("StationNum")]
    107.         public UInt16 StationNum { get {return stationNum; } set {stationNum=value; } }
    109.         [XmlElement("TrackCount")]
    110.         public byte TrackCount { get {return trackCount; } set {trackCount=value; } }
    112.         //[XmlArray("Tracks"),XmlArrayItem("Track")]
    113.         //public Track[] Tracks { get {return tracks; } set {tracks=value; } }
    115.         //[XmlArray("Tracks"), XmlArrayItem("Track")]
    116.         //public List<Track> Tracks { get { return tracks; } set { tracks = value; } }
    117.     }
    120.     [XmlRoot("TrackGIS")]
    121.     public class TrackGIS
    122.     {
    123.         //private TrackPiece[] trackPieces;//轨道片记录数据
    124.         private List<TrackPiece> trackPieces;
    125.         public TrackGIS()
    126.         {
    128.             //trackPieces = new TrackPiece[2];
    129.             trackPieces = new List<TrackPiece>(2);
    131.         }
    133.         public TrackGIS(/*TrackPiece[] tp*/List<TrackPiece> tp)
    134.         {
    135.             trackPieces = tp;
    136.         }
    139.         //[XmlArray("Track"), XmlArrayItem("TrackPiece")]
    140.         ////[XmlArray("TrackID"),XmlArrayItem("TrackPiece")]
    141.         //public TrackPiece[] TrackPieces { get {return trackPieces; } set {trackPieces=value; } }
    143.         [XmlArray("Track"),XmlArrayItem("TrackPiece")]
    144.         public List<TrackPiece> TrackPieces { get {return trackPieces; } set {trackPieces=value; } }
    146.     }
    148.     [XmlRoot("Track")]
    149.     public class Track
    150.     {
    151.         //字段
    152.         //轨道编号，单位无符号数1-255
    153.         private byte trackID;
    154.         //轨道特性
    155.         private int trackType;
    156.         //轨道特性名称
    157.         private string trackTypeName;
    158.         //起始位置，单位厘米，固定为0
    159.         private uint startMileage;
    160.         //起始纬度，单位毫秒
    161.         private int startLat;
    162.         //起始经度，单位毫秒
    163.         private int startLon;
    164.         //结束位置，单位厘米
    165.         private uint endMileage;
    166.         //结束纬度，单位毫秒
    167.         private int endLat;
    168.         //结束经度，单位毫秒
    169.         private int endLon;
    170.         //第一个轨道片的字节偏移
    171.         private string startAddress;
    172.         //最后一个轨道片的字节偏移，文件开始地址到当前轨道的最后一个轨道片记录点起始地址的字节偏移
    173.         private string endAddress;
    174.         public Track()
    175.         {
    176.             trackID = 0;
    177.             trackType = 0;
    178.             //trackTypeName = null;
    179.             startMileage = 0;
    180.             startLat = 0;
    181.             startLon = 0;
    182.             endMileage = 0;
    183.             endLat = 0;
    184.             endLon = 0;
    185.             startAddress = null;
    186.             endAddress = null;
    187.         }
    189.         public Track(byte ti, int ty, uint sm, int sLat,int sLon, uint em,int eLat,int eLon,string sA,string eA)
    190.         {
    191.             trackID = ti;
    192.             trackType = ty;
    193.             startMileage = sm;
    194.             startLat = sLat;
    195.             startLon = sLon;
    196.             endMileage = em;
    197.             endLat = eLat;
    198.             endLon = eLon;
    199.             startAddress = sA;
    200.             endAddress = eA;
    202.         }
    203.          enum tracktype : int
    204.         {
    205.             单线正线 = 1,
    206.             上行正线 = 2,
    207.             下行正线 = 3,
    208.             侧线 = 4,
    209.             其他 = 5
    210.         }
    212.         /// <summary>
    213.         /// 通过轨道特性索引得到轨道名称
    214.         /// </summary>
    215.         /// <param name="key"></param>
    216.         /// <returns></returns>
    217.         private string GetEnumNameByKey(int key)
    218.         {
    219.             return Enum.GetName(typeof(tracktype), key);
    220.         }
    222.         [XmlElement("TrackID")]
    223.         public byte TrackID { get { return trackID; } set { trackID = value; } }
    224.         //轨道特性，1-单线正线，2-上行正线，3-下行正线，4-侧线，5-其他
    225.         [XmlElement("TrackType")]
    226.         public int TrackType { get { return trackType; } set { trackType = value; } }
    228.         [XmlElement("StartMileage")]
    229.         public uint StartMileage { get { return startMileage; } set { startMileage = value; } }
    231.         [XmlElement("StartLat")]
    232.         public int StartLat { get { return startLat; } set { startLat = value; } }
    233.         [XmlElement("StartLon")]
    234.         public int StartLon { get { return startLon; } set { startLon = value; } }
    236.         [XmlElement("EndMileage")]
    237.         public uint EndMileage { get { return endMileage; } set { endMileage = value; } }
    239.         [XmlElement("EndLat")]
    240.         public int EndLat { get { return endLat; } set { endLat = value; } }
    242.         [XmlElement("EndLon")]
    243.         public int EndLon { get { return endLon; } set { endLon = value; } }
    245.         [XmlElement("StartAddress")]
    246.         public string StartAddress { get { return startAddress; } set { startAddress = value; } }
    248.         [XmlElement("EndAddress")]
    249.         public string EndAddress { get { return endAddress; } set { endAddress = value; } }
    251.         public string TrackTypeName
    252.         { get { return trackTypeName; } set { trackTypeName = value; } }
    254.     }
    256.     [XmlRoot("TrackPiece")]
    257.     public class TrackPiece
    258.     {
    259.         private uint deltaPos;//位置增量，厘米，
    260.         private int deltaLat;//纬度增量，毫秒，该轨道起始纬度到该轨道片记录点纬度的增量
    261.         private int deltaLon;//经度增量，单位毫秒，
    262.         private short deltaHeading;//增量航向角，
    263.         private int adjacentTrack;//邻近轨道，1-是，0-否
    264.         public enum adjacentTrackType
    265.         {
    266.             是 = 1,
    267.             否 = 0
    268.         }
    269.         private string GetEnumNameByKey(int key)
    270.         {
    271.             return Enum.GetName(typeof(adjacentTrackType), key);
    272.         }
    274.         public TrackPiece()
    275.         {
    276.             deltaPos = 0;
    277.             deltaLat = 0;
    278.             deltaLon = 0;
    279.             deltaHeading = 0;
    280.             adjacentTrack = 0;
    282.         }
    284.         public TrackPiece(uint dPos ,int dLat,int dLon,short dH,int aT)
    285.         {
    286.             deltaPos = dPos;
    287.             deltaLat = dLat;
    288.             deltaLon = dLon;
    289.             deltaHeading = dH;
    290.             adjacentTrack = aT;
    292.         }
    293.         [XmlElement("DeltaPos")]
    294.         public uint DeltaPos { get { return deltaPos; } set { deltaPos = value; } }
    295.         [XmlElement("DeltaLat")]
    296.         public int DeltaLat { get { return deltaLat; } set { deltaLat = value; } }
    297.         [XmlElement("DeltaLon")]
    298.         public int DeltaLon { get { return deltaLon; } set { deltaLon = value; } }
    299.         [XmlElement("DeltaHeading")]
    300.         public short DeltaHeading { get { return deltaHeading; } set { deltaHeading = value; } }
    301.         [XmlElement("AdjacentTrack")]
    302.         public int AdjacentTrack { get { return adjacentTrack; } set { adjacentTrack = value; } }
    303.     }
    304. }

    生成的xml文件
    在主程序里写了定义了完整的轨道地理信息文件

    static void Main(string[] args)
        {
            Serialize();//序列化
            //DeSerialize();//反序列化     
        }

        //序列化生成xml文件
        public static void Serialize()
        {
            ////测试TrackInfo--有TrackHeadInfo还有TrackGIS
            ///

            TrackFileProperty trackFileProperty = new TrackFileProperty(2, 2, 2, 2, 2, null);
            Track t1 = new Track(2, 2, 2, 3, 4, 5, 5, 6, "0xFFFFFFF", "0xFFFFFF");
            Track t2 = new Track(1, 1, 1, 1, 1, 1, 1, 1, "0xFFFFF", "0xFFFFF");

            TrackHeadInfo trackHeadInfo = new TrackHeadInfo();
            trackHeadInfo.TrackFileProperty = trackFileProperty;
            List<Track> ts = new List<Track>();
            ts.Add(t1);
            ts.Add(t2);
            trackHeadInfo.Tracks = ts;


            TrackGIS trackGIS = new TrackGIS();
            TrackPiece tp1 = new TrackPiece(1, 2, 3, 4, 5);
            TrackPiece tp2 = new TrackPiece(3, 4, 5, 6, 7);
            List<TrackPiece> a = new List<TrackPiece>();
            a.Add(tp1);
            a.Add(tp2);
            trackGIS.TrackPieces = a;

            TrackInfo trackInfo = new TrackInfo();
            trackInfo.TrackGIS = trackGIS;
            trackInfo.TrackHeadInfo = trackHeadInfo;
            try
            {

                ////可以强制删除命名空间，添加声明头
                XmlSerializer xs = new XmlSerializer(typeof(TrackInfo));
                FileStream fs = new FileStream("C:\\Users\\18333\\Desktop\\serialiable.xml", FileMode.Create);
                XmlWriterSettings settings = new XmlWriterSettings();
                settings.Indent = true;
                settings.IndentChars = "    ";
                settings.NewLineChars = "\r\n";
                settings.Encoding = Encoding.UTF8;
                settings.OmitXmlDeclaration = false;
                using (XmlWriter xmlWriter = XmlWriter.Create(fs, settings))
                {
                    XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
                    namespaces.Add(string.Empty, string.Empty);
                    xs.Serialize(xmlWriter, trackInfo, namespaces);//TrackInfo
                    xmlWriter.Close();
                }
                fs.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                Console.WriteLine(ex.Message);
            }
            Console.WriteLine("序列化成功！");
            Console.ReadKey();

        }

//反序列化
        public static void DeSerialize()
        {
            try
            {
                //测试TrackPiece
                //FileStream fs = new FileStream("C:\\Users\\18333\\Desktop\\TrackPiece.xml",FileMode.Open,FileAccess.Read);
                //XmlSerializer xs = new XmlSerializer(typeof(TrackPiece));
                //TrackPiece t = (TrackPiece)xs.Deserialize(fs);
                //Console.WriteLine(t.DeltaPos+"\r\n"+t.DeltaLon);

                ////测试Track
                //FileStream fs = new FileStream("C:\\Users\\18333\\Desktop\\Track.xml", FileMode.Open, FileAccess.Read);
                //XmlSerializer xs = new XmlSerializer(typeof(Track));
                //Track t = (Track)xs.Deserialize(fs);
                //Console.WriteLine(t.StartAddress + "\r\n" + t.EndAddress);

                ////测试TrackGIS
                //FileStream fs = new FileStream("C:\\Users\\18333\\Desktop\\Serialiable.xml", FileMode.Open, FileAccess.Read);
                //XmlSerializer xs = new XmlSerializer(typeof(TrackGIS));
                //TrackGIS t = (TrackGIS)xs.Deserialize(fs);
                //foreach (TrackPiece a in t.TrackPieces)
                //{
                //    Console.WriteLine(a.DeltaLat + "\r\n" + a.DeltaLon);
                //}

            }
            catch(Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.Read();
            Console.ReadKey();
        }
    }

    生成的xml文件

    <?xml version="1.0" encoding="utf-8"?>
<TrackInfo>
    <TrackHeadInfo>
        <TrackFileProperty>
            <FileType>2</FileType>
            <FileStructVersion>2</FileStructVersion>
            <FileDataVersion>2</FileDataVersion>
            <StationNum>2</StationNum>
            <TrackCount>2</TrackCount>
        </TrackFileProperty>
        <Tracks>
            <Track>
                <TrackID>2</TrackID>
                <TrackType>2</TrackType>
                <StartMileage>2</StartMileage>
                <StartLat>3</StartLat>
                <StartLon>4</StartLon>
                <EndMileage>5</EndMileage>
                <EndLat>5</EndLat>
                <EndLon>6</EndLon>
                <StartAddress>0xFFFFFFF</StartAddress>
                <EndAddress>0xFFFFFF</EndAddress>
            </Track>
            <Track>
                <TrackID>1</TrackID>
                <TrackType>1</TrackType>
                <StartMileage>1</StartMileage>
                <StartLat>1</StartLat>
                <StartLon>1</StartLon>
                <EndMileage>1</EndMileage>
                <EndLat>1</EndLat>
                <EndLon>1</EndLon>
                <StartAddress>0xFFFFF</StartAddress>
                <EndAddress>0xFFFFF</EndAddress>
            </Track>
        </Tracks>
    </TrackHeadInfo>
    <TrackGIS>
        <Track>
            <TrackPiece>
                <DeltaPos>1</DeltaPos>
                <DeltaLat>2</DeltaLat>
                <DeltaLon>3</DeltaLon>
                <DeltaHeading>4</DeltaHeading>
                <AdjacentTrack>5</AdjacentTrack>
            </TrackPiece>
            <TrackPiece>
                <DeltaPos>3</DeltaPos>
                <DeltaLat>4</DeltaLat>
                <DeltaLon>5</DeltaLon>
                <DeltaHeading>6</DeltaHeading>
                <AdjacentTrack>7</AdjacentTrack>
            </TrackPiece>
        </Track>
    </TrackGIS>
</TrackInfo>

    由于上一版定义了TrackGIS只有一个轨道的多轨道片数据
    第三版

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Xml.Serialization;
using System.ComponentModel;
using System.Xml;

namespace TrackGeoInfo
{

    //轨道地理信息文件包括信息头和TrackGIS轨道片记录点的数据
    [Serializable]
    [XmlRoot("TrackInfo")]
    public class TrackInfo
    {
        private TrackHeadInfo trackHeadInfo;
        private TrackGIS trackGIS;

        public TrackInfo()
        {
            trackHeadInfo = null;
            trackGIS = null;

        }
        public TrackInfo(TrackHeadInfo th,TrackGIS tg)
        {
            trackHeadInfo = th;
            trackGIS = tg;
        }

        [XmlElement("TrackHeadInfo")]
        public TrackHeadInfo TrackHeadInfo { get {return trackHeadInfo; } set {trackHeadInfo=value; } }

        //[XmlElement("TrackGIS")]
        //public TrackGIS TrackGIS { get {return trackGIS; } set {trackGIS=value; } }
        [XmlElement("TrackGIS")]
        public TrackGIS TrackGIS { get { return trackGIS; } set { trackGIS = value; } }

    }

    #region 轨道地理信息头(包含轨道地理信息文件属性和轨道集)

    [XmlRoot("TrackHeadInfo")]
    public class TrackHeadInfo
    {
        private TrackFileProperty trackFileProperty;//轨道地理数据信息头
        private List<Track> tracks;
        public TrackHeadInfo()
        {
            trackFileProperty = null;
            tracks = null;
        }
        public TrackHeadInfo(TrackFileProperty tf,List<Track> ts)
        {
            trackFileProperty = tf;
            tracks = ts;
        }
        [XmlElement("TrackFileProperty")]
        public TrackFileProperty TrackFileProperty { get { return trackFileProperty; } set { trackFileProperty = value; } }


        [XmlArray("Tracks"),XmlArrayItem("Track")]
        public List<Track> Tracks { get {return tracks; } set {tracks=value; } }
    }

    #region 轨道地理信息文件属性

    [XmlRoot("TrackFileProperty")]
    public class TrackFileProperty
    {
        private byte fileType;//文件类型固定为1
        private byte fileStructVersion;//文件结构版本
        private byte fileDataVersion;//文件数据版本
        private UInt16 stationNum;//车站编号
        private byte trackCount;//轨道个数

        public TrackFileProperty()
        {
            fileType = 0;
            fileStructVersion = 0;
            fileDataVersion = 0;
            stationNum = 0;
            trackCount = 0;
        }
        public TrackFileProperty(byte ft,byte fsv,byte fdv,UInt16 sn,byte tc,Track[] ts)
        {
            fileType = ft;
            fileStructVersion = fsv;
            fileDataVersion = fdv;
            stationNum = sn;
            trackCount = tc;
        }

        [XmlElement("FileType")]
        public byte FileType { get { return fileType; } set { fileType = value; } }
        [XmlElement("FileStructVersion")]
        public byte FileStructVersion { get {return fileStructVersion; } set { fileStructVersion = value; } }
        [XmlElement("FileDataVersion")]
        public byte FileDataVersion { get {return fileDataVersion; } set { fileDataVersion = value; } }
        [XmlElement("StationNum")]
        public UInt16 StationNum { get {return stationNum; } set {stationNum=value; } }

        [XmlElement("TrackCount")]
        public byte TrackCount { get {return trackCount; } set {trackCount=value; } }
    }
    #endregion 

    #region 轨道属性
    [XmlRoot("Track")]
    public class Track
    {
        //字段
        //轨道编号，单位无符号数1-255
        private byte trackID;
        //轨道特性
        private int trackType;
        //轨道特性名称
        private string trackTypeName;
        //起始位置，单位厘米，固定为0
        private uint startMileage;
        //起始纬度，单位毫秒
        private int startLat;
        //起始经度，单位毫秒
        private int startLon;
        //结束位置，单位厘米
        private uint endMileage;
        //结束纬度，单位毫秒
        private int endLat;
        //结束经度，单位毫秒
        private int endLon;
        //第一个轨道片的字节偏移
        private string startAddress;
        //最后一个轨道片的字节偏移，文件开始地址到当前轨道的最后一个轨道片记录点起始地址的字节偏移
        private string endAddress;
        public Track()
        {
            trackID = 0;
            trackType = 0;
            //trackTypeName = null;
            startMileage = 0;
            startLat = 0;
            startLon = 0;
            endMileage = 0;
            endLat = 0;
            endLon = 0;
            startAddress = null;
            endAddress = null;
        }

        public Track(byte ti, int ty, uint sm, int sLat, int sLon, uint em, int eLat, int eLon, string sA, string eA)
        {
            trackID = ti;
            trackType = ty;
            startMileage = sm;
            startLat = sLat;
            startLon = sLon;
            endMileage = em;
            endLat = eLat;
            endLon = eLon;
            startAddress = sA;
            endAddress = eA;

        }
        enum tracktype : int
        {
            单线正线 = 1,
            上行正线 = 2,
            下行正线 = 3,
            侧线 = 4,
            其他 = 5
        }

        /// <summary>
        /// 通过轨道特性索引得到轨道名称
        /// </summary>
        /// <param name="key"></param>
        /// <returns></returns>
        private string GetEnumNameByKey(int key)
        {
            return Enum.GetName(typeof(tracktype), key);
        }

        [XmlElement("TrackID")]
        public byte TrackID { get { return trackID; } set { trackID = value; } }
        //轨道特性，1-单线正线，2-上行正线，3-下行正线，4-侧线，5-其他
        [XmlElement("TrackType")]
        public int TrackType { get { return trackType; } set { trackType = value; } }

        [XmlElement("StartMileage")]
        public uint StartMileage { get { return startMileage; } set { startMileage = value; } }

        [XmlElement("StartLat")]
        public int StartLat { get { return startLat; } set { startLat = value; } }
        [XmlElement("StartLon")]
        public int StartLon { get { return startLon; } set { startLon = value; } }

        [XmlElement("EndMileage")]
        public uint EndMileage { get { return endMileage; } set { endMileage = value; } }

        [XmlElement("EndLat")]
        public int EndLat { get { return endLat; } set { endLat = value; } }

        [XmlElement("EndLon")]
        public int EndLon { get { return endLon; } set { endLon = value; } }

        [XmlElement("StartAddress")]
        public string StartAddress { get { return startAddress; } set { startAddress = value; } }

        [XmlElement("EndAddress")]
        public string EndAddress { get { return endAddress; } set { endAddress = value; } }

        public string TrackTypeName
        { get { return trackTypeName; } set { trackTypeName = value; } }

    }

    #endregion



    #endregion
    #region 轨道片数据(包括多个轨道的轨道片数据)

    [XmlRoot("TrackGIS")]
    public class TrackGIS
    {
        private List<TrackPieceGIS> trackPieceGIS;
        public TrackGIS()
        {
            trackPieceGIS = null;
        }

        public TrackGIS(List<TrackPieceGIS> tp)
        {
            trackPieceGIS = tp;
        }

        [XmlElement("Track")]
        public List<TrackPieceGIS> TrackPieceGIS { get {return trackPieceGIS; } set {trackPieceGIS=value; } }
    }

    #region 每个轨道的轨道片记录数据(包括轨道的ID还有此轨道轨道片的数据)
    [XmlRoot("Track")]
    public class TrackPieceGIS
    {
        private int trackID;
        private List<TrackPiece> trackPieces;
        public TrackPieceGIS()
        {
            trackID = 1;
            trackPieces = new List<TrackPiece>();
            trackPieces.Add(new TrackPiece(1, 2, 3, 4, 5));
            trackPieces.Add(new TrackPiece(5, 4, 3, 2, 1));
        }

        public TrackPieceGIS(int trackid,List<TrackPiece> ts)
        {
            trackID = trackid;
            trackPieces = ts;
        }
        [XmlElement("TrackID")]
        public int TrackID { get {return trackID; } set {trackID= value; } }

       [XmlElement("TrackPiece")]
        public List<TrackPiece> TrackPieces { get {return trackPieces; } set {trackPieces = value; } }
    }
    #endregion

    #region 轨道片记录点属性
    [XmlRoot("TrackPiece")]
    public class TrackPiece
    {
        private uint deltaPos;//位置增量，厘米，
        private int deltaLat;//纬度增量，毫秒，该轨道起始纬度到该轨道片记录点纬度的增量
        private int deltaLon;//经度增量，单位毫秒，
        private short deltaHeading;//增量航向角，
        private int adjacentTrack;//邻近轨道，1-是，0-否
        public enum adjacentTrackType
        {
            是 = 1,
            否 = 0
        }
        private string GetEnumNameByKey(int key)
        {
            return Enum.GetName(typeof(adjacentTrackType), key);
        }

        public TrackPiece()
        {
            deltaPos = 0;
            deltaLat = 0;
            deltaLon = 0;
            deltaHeading = 0;
            adjacentTrack = 0;

        }

        public TrackPiece(uint dPos ,int dLat,int dLon,short dH,int aT)
        {
            deltaPos = dPos;
            deltaLat = dLat;
            deltaLon = dLon;
            deltaHeading = dH;
            adjacentTrack = aT;

        }
        [XmlElement("DeltaPos")]
        public uint DeltaPos { get { return deltaPos; } set { deltaPos = value; } }
        [XmlElement("DeltaLat")]
        public int DeltaLat { get { return deltaLat; } set { deltaLat = value; } }
        [XmlElement("DeltaLon")]
        public int DeltaLon { get { return deltaLon; } set { deltaLon = value; } }
        [XmlElement("DeltaHeading")]
        public short DeltaHeading { get { return deltaHeading; } set { deltaHeading = value; } }
        [XmlElement("AdjacentTrack")]
        public int AdjacentTrack { get { return adjacentTrack; } set { adjacentTrack = value; } }

    }
    #endregion

    #endregion
}

    这下生成的xml文件基本上和规范的没差

    <?xml version="1.0" encoding="utf-8"?>
<TrackInfo>
    <TrackHeadInfo>
        <TrackFileProperty>
            <FileType>2</FileType>
            <FileStructVersion>2</FileStructVersion>
            <FileDataVersion>2</FileDataVersion>
            <StationNum>2</StationNum>
            <TrackCount>2</TrackCount>
        </TrackFileProperty>
        <Tracks>
            <Track>
                <TrackID>2</TrackID>
                <TrackType>2</TrackType>
                <StartMileage>2</StartMileage>
                <StartLat>3</StartLat>
                <StartLon>4</StartLon>
                <EndMileage>5</EndMileage>
                <EndLat>5</EndLat>
                <EndLon>6</EndLon>
                <StartAddress>0xFFFFFFF</StartAddress>
                <EndAddress>0xFFFFFF</EndAddress>
            </Track>
            <Track>
                <TrackID>1</TrackID>
                <TrackType>1</TrackType>
                <StartMileage>1</StartMileage>
                <StartLat>1</StartLat>
                <StartLon>1</StartLon>
                <EndMileage>1</EndMileage>
                <EndLat>1</EndLat>
                <EndLon>1</EndLon>
                <StartAddress>0xFFFFF</StartAddress>
                <EndAddress>0xFFFFF</EndAddress>
            </Track>
        </Tracks>
    </TrackHeadInfo>
    <TrackGIS>
        <Track>
            <TrackID>1</TrackID>
            <TrackPiece>
                <DeltaPos>1</DeltaPos>
                <DeltaLat>2</DeltaLat>
                <DeltaLon>3</DeltaLon>
                <DeltaHeading>4</DeltaHeading>
                <AdjacentTrack>5</AdjacentTrack>
            </TrackPiece>
            <TrackPiece>
                <DeltaPos>5</DeltaPos>
                <DeltaLat>4</DeltaLat>
                <DeltaLon>3</DeltaLon>
                <DeltaHeading>2</DeltaHeading>
                <AdjacentTrack>1</AdjacentTrack>
            </TrackPiece>
        </Track>
        <Track>
            <TrackID>2</TrackID>
            <TrackPiece>
                <DeltaPos>5</DeltaPos>
                <DeltaLat>6</DeltaLat>
                <DeltaLon>7</DeltaLon>
                <DeltaHeading>8</DeltaHeading>
                <AdjacentTrack>9</AdjacentTrack>
            </TrackPiece>
            <TrackPiece>
                <DeltaPos>9</DeltaPos>
                <DeltaLat>8</DeltaLat>
                <DeltaLon>7</DeltaLon>
                <DeltaHeading>6</DeltaHeading>
                <AdjacentTrack>5</AdjacentTrack>
            </TrackPiece>
        </Track>
    </TrackGIS>
</TrackInfo>