C# XML 使用教程

十⑧

已于 2024-09-04 19:19:42 修改

阅读量1.7k

点赞数 13

分类专栏： C# 通用的知识文章标签： c# xml 后端

于 2024-09-04 19:16:19 首次发布

本文链接：https://blog.csdn.net/weixin_46766584/article/details/141901619

版权

通用的知识同时被 2 个专栏收录

20 篇文章 1 订阅

订阅专栏

1 篇文章 0 订阅

订阅专栏

C# XML 使用教程

XML 是什么

介绍

可扩展标记语言 (Extensible Markup Language, XML) ，标准通用标记语言的子集，可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。
XML 是标准通用标记语言，可扩展性良好、内容与形式分离、遵循严格的语法要求、保值性良好、可读性优等优点。
在电子计算机中，标记指计算机所能理解的信息符号，通过此种标记，计算机之间可以处理包含各种的信息比如文章等。
它可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。

组成

声明语句：XML 声明是 XML 文档的第一句，格式如下，version 表示 XML 版本，encoding 表示 XML 编码格式。

<?xml version="1.0" encoding="utf-8"?>

元素:良好格式的 XML 文档必须有一个根元素，就是紧接着声明后面建立的第一个元素，其他元素都是这个根元素的子元素，根元素完全包括文档中其他所有的元素。根元素的起始标记要放在所有其他元素的起始标记之前；根元素的结束标记要放在所有其他元素的结束标记之后。

<?xml version="1.0" encoding="utf-8"?>
<packages>
  <!-- <packages> 是起始标记；</packages> 是结束标记 -->
  <package id="Microsoft.Windows.Shell" version="3.0.1.0" targetFramework="net40" />
  <package></package> 
  <package /> 
  <!-- <package></package> 等同于 <package />，起始标记和结束标记之间没有内容时可以替换 -->
</packages>

区分大小写：在XML文档中，大小写是有区别的。'A’和’a’是不同的标记。注意在写元素时，前后标记的大小写要保持一致。
命名空间：在下方的 XML 中，除开manifest 外，manifest 元素起始标记中的所有都属于命名空间。

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="osg.AndroidExample"
      android:installLocation="preferExternal"
      android:versionCode="1"
      android:versionName="1.0">
</manifest>

属性值使用引号：XML 规定，所有属性值必须加引号（可以是单引号，也可以是双引号，建议使用双引号），否则将被视为错误。
所有的标记必须有相应的结束标记：所有标记必须成对出现，有一个开始标记，就必须有一个结束标记，否则将被视为错误。空标记是指标记对之间没有内容的标记，同样，空标记也要有结束标记。

XML 与 HTML 的区别

可扩展性方面：HTML 不允许用户自行定义自己的标识或属性，而在 XML 中，用户能够根据需要自行定义新的标识及属性名，以便更好地从语义上修饰数据。
结构性方面：HTML 不支持深层的结构描述，XML 的文件结构嵌套可以复杂到任意程度，能表示面向对象的等级层次。
可校验性方面：HTML 没有提供规范文件以支持应用软件对 HTML 文件进行结构校验，而 XML 文件可以包括一个语法描述，使应用程序可以对此文件进行结构校验。

C# 中如何使用 XML

在 C# 中可以将类对像序列化成 XML 文本进行传输；接收到 XML 文本再转换成对应的类对象。

序列化

首先添加 XML、Xml.Serialization 的引用

using System.Xml;
using System.Xml.Serialization;

以 MessageDataXml 类来测试，目标是将 MessageDataXml 类对象转换成 XML 文本

根元素

根元素是 MessageDataXml，设定元素是 MessageData。类的空构造函数记得添加。

[XmlRoot("MessageData")]
public class MessageDataXml
{
    public MessageDataXml()
    {
    }
}

子元素

子元素有 Label、FunctionName、Type、Key、Equipment、ReplyQueue、ReturnCode、ReturnMessage、ContentXml，设定元素分别是 Label、FunctionName、Type、Key、Equipment、ReplyQueue、ReturnCode、ReturnMessage、Content。

[XmlElement("Label")]
public string Label { get; set; }

    ...

[XmlElement("Content")]
 public Content ContentXml { get; set; }

Content 这个子元素是一个类，所以需要添加一个 MessageDataXml 的内部类 Content。
同样，子元素 Content 的子元素 GetLotInfoDataXml 也是一个类，所以需要添加一个 Content 的内部类 GetLotInfoDataXml。
下面是MessageDataXml 全部的元素和标记命名

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

namespace MSMQ
{
    [XmlRoot("MessageData")]
    public class MessageDataXml
    {
        [XmlInclude(typeof(Content))]
        public class Content
        {
            [XmlElement("GetLotInfoData")]
            public GetLotInfoData GetLotInfoDataXml { get; set; }

            public Content()
            {
            }

            [XmlInclude(typeof(GetLotInfoData))]
            public class GetLotInfoData
            {
                [XmlElement("Lot")]
                public string Lot { get; set; }

                [XmlElement("ErpLot")]
                public string ErpLot { get; set; }

                public GetLotInfoData()
                {
                }
            }
        }

        [XmlElement("Label")]
        public string Label { get; set; }

        [XmlElement("FunctionName")]
        public string FunctionName { get; set; }

        [XmlElement("Type")]
        public string Type { get; set; }

        [XmlElement("Key")]
        public string Key { get; set; }

        [XmlElement("Equipment")]
        public string Equipment { get; set; }

        [XmlElement("ReplyQueue")]
        public string ReplyQueue { get; set; }

        [XmlElement("ReturnCode")]
        public string ReturnCode { get; set; }

        [XmlElement("ReturnMessage")]
        public string ReturnMessage { get; set; }

        [XmlElement("Content")]
        public Content ContentXml { get; set; }

        public MessageDataXml()
        {
        }
    }

序列化方法

XmlWriterSettings 是 XML 格式设定类；MemoryStream 是内存流对象；XmlSerializerNamespaces 是 XML 命名空间设定类；XmlWriter 是 XML 写入器，用来生成 XML 文本。

/// <summary>
/// 将 MessageDataXml 序列化成 XML 字符串
/// </summary>
/// <param name="encoding">字符编码格式</param>
/// <returns>XML 字符串</returns>
public string SerializeToXML(Encoding encoding)
{
    XmlWriterSettings settings = new XmlWriterSettings {
        // 保留 xml 声明
        OmitXmlDeclaration = false,
        Encoding = encoding,
        // 换行缩进
        Indent = true
    };

    MemoryStream mem = new MemoryStream();
    using (XmlWriter writer = XmlWriter.Create(mem, settings))
    {
        //去除默认命名空间xmlns:xsd和xmlns:xsi
        XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
        ns.Add("", "");
        XmlSerializer serializer = new XmlSerializer(typeof(MessageDataXml));
        serializer.Serialize(writer, this, ns);
    }
    return encoding.GetString(mem.ToArray());
}

序列化方法也可以改成泛型方法，方便复用

/// <summary>
/// 将 类对象序列化成 XML 字符串
/// </summary>
/// /// <typeparam name="T">类泛型</typeparam>
/// <param name="t">类对象</param>
/// <param name="encoding">字符编码格式</param>
/// <returns>XML 字符串</returns>
public static string XMLConvert<T>(T t, Encoding encoding)
{
    XmlWriterSettings settings = new XmlWriterSettings {
        // 保留 xml 声明，这个 <?xml version="1.0" encoding="utf-8"?>
        OmitXmlDeclaration = false,
        Encoding = encoding,
        // 换行缩进
        Indent = true
    };

    MemoryStream mem = new MemoryStream();
    using (XmlWriter writer = XmlWriter.Create(mem, settings))
    {
        //去除默认命名空间xmlns:xsd和xmlns:xsi
        XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
        ns.Add("", "");
        XmlSerializer serializer = new XmlSerializer(typeof(T));
        serializer.Serialize(writer, t, ns);
    }
    return encoding.GetString(mem.ToArray());
}

反序列化

同样添加 XML、Xml.Serialization、IO 的引用

using System.Xml;
using System.Xml.Serialization;
using System.IO;

反序列化方法

XmlWriterSettings 是 XML 格式设定类；MemoryStream 是内存流对象；XmlTextReader 是 XML 读取器。

/// <summary>
/// 将 XML 字符串反序列化成 MessageDataXml 类
/// </summary>
/// <param name="xml">XML 字符串</param>
/// <param name="encoding">字符串编码格式</param>
/// <returns>MessageData 类</returns>
public static MessageDataXml DeserializeFromXML(string xml, Encoding encoding)
{
    XmlSerializer serializer = new XmlSerializer(typeof(MessageDataXml));
    // 根据指定编码格式获取 XML 文本
    byte[] byteArray = encoding.GetBytes(xml);
    MemoryStream memoryStream = new MemoryStream(byteArray);
    using (StreamReader streamReader = new StreamReader(memoryStream, encoding))
    {
        // 防止XML外部实体攻击
        using (XmlTextReader xmlReader = new XmlTextReader(streamReader) { XmlResolver = null })
        {
            xmlReader.Normalization = false;
            return (MessageDataXml) serializer.Deserialize(xmlReader);
        }
    }
}

反序列化方法也可以改成泛型方法，方便复用

/// <summary>
/// 将 XML 字符串反序列化成 类对象
/// </summary>
/// <typeparam name="T">类泛型</typeparam>
/// <param name="xml">XML 字符串</param>
/// <param name="encoding">字符串编码格式</param>
/// <returns>泛型 T</returns>
public static T ParseXml<T>(string xml, Encoding encoding)
{
    XmlSerializer serializer = new XmlSerializer(typeof(T));
    byte[] byteArray = encoding.GetBytes(xml);
    MemoryStream memoryStream = new MemoryStream(byteArray);
    using (StreamReader streamReader = new StreamReader(memoryStream, encoding))
    {
        // 防止XML外部实体攻击
        using (XmlTextReader xmlReader = new XmlTextReader(streamReader) { XmlResolver = null })
        {
            xmlReader.Normalization = false;
            return (T) serializer.Deserialize(xmlReader);
        }
    }
}

序列化与反序列化实例

// 创建一个 MessageDataXml，然后序列化成 XML 文本
Guid newGuid = Guid.NewGuid();
MessageDataXml.Content.GetLotInfoData getLotInfoDataXml = new MessageDataXml.Content.GetLotInfoData {
    Lot = "Lot_112233"
};
MessageDataXml.Content contentXml = new MessageDataXml.Content {
    GetLotInfoDataXml = getLotInfoDataXml
};
MessageDataXml messageDataXml = new MessageDataXml("queueName_001", newGuid.ToString(), "equ_001", "path_001", contentXml);
string s1 = messageDataXml.SerializeToXML(Encoding.Unicode);
string s2 = MessageDataXml.XMLConvert<MessageDataXml>(messageDataXml, Encoding.Unicode);

// 创填入 XML 文本，反序列化成 MessageDataXml 类对象
MessageDataXml messageDataXml = MessageDataXml.DeserializeFromXML(s1, Encoding.Unicode);
MessageDataXml messageDataXml1 = MessageDataXml.ParseXml<MessageDataXml>(s2, Encoding.Unicode);

最终结果

<MessageData>
    <Label>2024/08/30 3:28:28</Label>
    <FunctionName></FunctionName>
    <Type>Request</Type>
    <Key>4a2e99ef-5249-4b9c-ac6a-e3491a80fcdc</Key>
    <Equipment>equ_001</Equipment>
    <ReplyQueue>path_001</ReplyQueue>
    <ReturnCode>000000</ReturnCode>
    <ReturnMessage />
    <Content>
        <GetLotInfoData>
            <Lot>Lot_112233</Lot>
        </GetLotInfoData>
    </Content>
</MessageData>