-
C# LINQ学习笔记五：LINQ to XML
本笔记摘抄自：https://www.cnblogs.com/yaozhenfa/p/CSharp_Linq_For_Xml.html，记录一下学习过程以备后续查用。
一、生成xml
1.1创建简单的xml
/// <summary>
/// CreateXml类
/// </summary>
public class CreateXml
{
/// <summary>
/// 返回xml文件路径
/// </summary>
public string Path
{
get
{
string path = @"....LinqToXml.xml";
return path;
}
}
/// <summary>
/// 创建简单的xml并保存
/// </summary>
public void CreateElement()
{
XDocument xdoc = new XDocument
(
//创建一个xml文档
//设置该xml的版本为1.0，采用utf - 8编码，后面的yes表示该xml是独立的。
new XDeclaration("1.0", "utf-8", "yes"),
//开始创建每个节点的，首先是Root节点，然后在Root节点中添加两个Item节点。
new XElement
(
"Root",
new XElement("Item", "1"),
new XElement("Item", "2")
)
);
xdoc.Save(Path);
}
}
class Program
{
static void Main(string[] args)
{
#region 创建简单的xml
CreateXml xml = new CreateXml();
xml.CreateElement();
#endregion
}
}
最终生成的xml如下所示：
<?xml version="1.0" encoding="utf-8" standalone="yes"?> <Root> <Item>1</Item> <Item>2</Item> </Root>
1.2创建xml注释
当xml有很多项时，我们就需要利用注释加以区别，通过linq to xml我们一样可以在其中添加注释。
/// <summary>
/// CreateXml类
/// </summary>
public class CreateXml
{
/// <summary>
/// 返回xml文件路径
/// </summary>
public string Path
{
get
{
string path = @"....LinqToXml.xml";
return path;
}
}
/// <summary>
/// 创建xml注释
/// </summary>
public void CreateComment()
{
XDocument xdoc = new XDocument
(
new XDeclaration("1.0", "utf-8", "yes"),
new XComment("这里是注释"),
new XElement
(
"Root",
new XElement("Item", "1"),
new XElement("Item", "2")
)
);
xdoc.Save(Path);
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 创建xml注释
CreateXml xml = new CreateXml();
xml.CreateComment();
#endregion
}
}
最终生成的xml如下所示：
<?xml version="1.0" encoding="utf-8" standalone="yes"?> <!--这里是注释--> <Root> <Item>1</Item> <Item>2</Item> </Root>
1.3根据对象创建xml
很多时候我们都会将数组之类的类型转换成xml以便保存进永久性存储介质中。
/// <summary>
/// CreateXml类
/// </summary>
public class CreateXml
{
/// <summary>
/// 返回xml文件路径
/// </summary>
public string Path
{
get
{
string path = @"....LinqToXml.xml";
return path;
}
}
/// <summary>
/// 根据对象创建xml并保存
/// </summary>
public void CreateElementByObjects()
{
var objs = Enumerable.Range(1, 6);
XElement xe = new XElement
(
"Root",
from obj in objs
select new XElement("Item", obj.ToString())
);
xe.Save(Path);
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 根据对象创建xml
CreateXml xml = new CreateXml();
xml.CreateElementByObjects();
#endregion
}
}
最终生成的xml如下所示：
<?xml version="1.0" encoding="utf-8"?> <Root> <Item>1</Item> <Item>2</Item> <Item>3</Item> <Item>4</Item> <Item>5</Item> <Item>6</Item> </Root>
1.4创建xml属性
有时我们不想创建新的子项去保存数据，而是使用属性的方式去保存。理所应当，linq to xml一样也支持这个功能，下面我们可以通过简单的语句去
实现它。
/// <summary>
/// CreateXml类
/// </summary>
public class CreateXml
{
/// <summary>
/// 返回xml文件路径
/// </summary>
public string Path
{
get
{
string path = @"....LinqToXml.xml";
return path;
}
}
/// <summary>
/// 创建xml属性
/// </summary>
public void CreateAttribute()
{
XAttribute xa = new XAttribute("V2", "2");
XElement xe = new XElement
(
"Root",
new XElement
(
"Item",
new XAttribute("V1", "1"),
xa
)
);
xe.Save(Path);
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 创建xml属性
CreateXml xml = new CreateXml();
xml.CreateAttribute();
#endregion
}
}
最终生成的xml如下所示：
<?xml version="1.0" encoding="utf-8"?> <Root> <Item V1="1" V2="2" /> </Root>
1.5创建xml命名空间
对于一些企业级的xml格式，会非常的严格，特别是在同一个xml中可能会出现重复的项，但是我们又想区分开来，这个时候我们可以利用命名空间将
他们分开（跟C#中的命名空间类似）。
/// <summary>
/// CreateXml类
/// </summary>
public class CreateXml
{
/// <summary>
/// 返回xml文件路径
/// </summary>
public string Path
{
get
{
string path = @"....LinqToXml.xml";
return path;
}
}
/// <summary>
/// 创建xml命名空间
/// </summary>
public void CreateNamespace()
{
XElement xe = new XElement
(
"{http://www.xamarin-cn.com/}Root",
new XElement("Item", "1"),
new XElement("{http://www.baidu.com/}Item", 2)
);
xe.Save(Path);
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 创建xml命名空间
CreateXml xml = new CreateXml();
xml.CreateNamespace();
#endregion
}
}
最终生成的xml如下所示：
<?xml version="1.0" encoding="utf-8"?> <Root xmlns="http://www.xamarin-cn.com/"> <Item xmlns="">1</Item> <Item xmlns="http://www.baidu.com/">2</Item> </Root>
从这个结果中我们可以看到对应的属性中有了xmlns属性，并且值就是我们赋给它的命名空间。
二、查询并修改Xml
linq to xml不仅创建xml简单，在查询、编辑和删除方面也一样是非常方便的。
创建一个XmlReadWrite.xml文件：
<?xml version="1.0" encoding="utf-8"?> <Root> <Item v1="1" v2="2">Item1</Item> <Item v1="1" v2="2">Item2</Item> </Root>
2.1读取xml文件
/// <summary>
/// QueryXml类
/// </summary>
public class QueryXml
{
/// <summary>
/// 返回xml文件路径
/// </summary>
public string Path
{
get
{
string path = @"....XmlReadWrite.xml";
return path;
}
}
/// <summary>
/// 读取xml文件
/// </summary>
public void QueryElementByFile()
{
XElement xe = XElement.Load(Path);
XElement xe1 = xe.Element("Item");
Console.Write(xe1.Value.Trim());
Console.ReadKey();
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 读取xml文件
QueryXml xml = new QueryXml();
xml.QueryElementByFile();
#endregion
}
}
运行结果如下：
上面的示例，我们利用XElement的静态方法Load读取指定路径下的xml文件，同时还获取了该xml文件的第一个item的值并输出。
2.2在xml指定节点前后添加新节点
/// <summary>
/// QueryXml类
/// </summary>
public class QueryXml
{
/// <summary>
/// 返回xml文件路径
/// </summary>
public string Path
{
get
{
string path = @"....XmlReadWrite.xml";
return path;
}
}
/// <summary>
/// 在xml指定节点前后添加新节点
/// </summary>
public void AddElementBeforeAndAfter()
{
XElement xe = XElement.Load(Path);
var item = (from t in xe.Elements("Item")
where t.Value.Equals("Item2")
select t).SingleOrDefault();
if (item != null)
{
XElement bxe = new XElement("Item", "ItemB");
XElement axe = new XElement("Item", "ItemA");
item.AddBeforeSelf(bxe);
item.AddAfterSelf(axe);
xe.Save(Path);
}
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 在xml指定节点前后添加新节点
QueryXml xml = new QueryXml();
xml.AddElementBeforeAndAfter();
#endregion
}
}
最终生成的xml如下所示：
<?xml version="1.0" encoding="utf-8"?> <Root> <Item v1="1" v2="2">Item1</Item> <Item>ItemB</Item> <Item v1="1" v2="2">Item2</Item> <Item>ItemA</Item> </Root>
2.3添加属性到xml节点中
我们已经可以动态的添加节点，但是创建的时候不仅仅可以创建节点，并且还能创建属性，下面我们可以通过SetAttributeValue去添加新的属性或者
修改现有属性。
/// <summary>
/// QueryXml类
/// </summary>
public class QueryXml
{
/// <summary>
/// 返回xml文件路径
/// </summary>
public string Path
{
get
{
string path = @"....XmlReadWrite.xml";
return path;
}
}
/// <summary>
/// 添加属性到xml节点中
/// </summary>
public void AddAttributeToElement()
{
XElement xe = XElement.Parse(@"<?xml version='1.0' encoding='utf-8'?><Root>
<Item v1='1' v2='2'>Item1</Item><Item v1='1' v2='2'>Item2</Item></Root>");
var item = (from t in xe.Elements("Item")
where t.Value.Equals("Item2")
select t).SingleOrDefault();
item.SetAttributeValue("v3", "3");
xe.Save(Path);
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 添加属性到xml节点中
QueryXml xml = new QueryXml();
xml.AddAttributeToElement();
#endregion
}
}
最终生成的xml如下所示：
<?xml version="1.0" encoding="utf-8"?> <Root> <Item v1="1" v2="2">Item1</Item> <Item v1="1" v2="2" v3="3">Item2</Item> </Root>
2.4添加注释到xml指定节点前后
这里的语法基本跟【在xml指定节点前后添加新节点】是相似的，只是读取xml的方式不同。
/// <summary>
/// QueryXml类
/// </summary>
public class QueryXml
{
/// <summary>
/// 返回xml文件路径
/// </summary>
public string Path
{
get
{
string path = @"....XmlReadWrite.xml";
return path;
}
}
/// <summary>
/// 添加注释到xml指定节点前后
/// </summary>
public void AddCommentBeforeAndAfter()
{
TextReader tr = new StringReader(@"<?xml version='1.0' encoding='utf-8'?><Root>
<Item v1='1' v2='2'>Item1</Item><Item v1='1' v2='2' v3='3'>Item2</Item></Root>");
XElement xe = XElement.Load(tr);
var item = (from t in xe.Elements("Item")
where t.Value.Equals("Item1")
select t).FirstOrDefault();
if (item != null)
{
XComment bcom = new XComment("前面的注释");
XComment acom = new XComment("后面的注释");
item.AddBeforeSelf(bcom);
item.AddAfterSelf(acom);
}
tr.Close();
xe.Save(Path);
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 添加注释到xml指定节点前后
QueryXml xml = new QueryXml();
xml.AddCommentBeforeAndAfter();
#endregion
}
}
最终生成的xml如下所示：
<?xml version="1.0" encoding="utf-8"?> <Root> <!--前面的注释--> <Item v1="1" v2="2">Item1</Item> <!--后面的注释--> <Item v1="1" v2="2" v3="3">Item2</Item> </Root>
2.5替换xml指定节点
修改节点的值通过SetValue即可做到，但是有时涉及到子节点，而我们想一次性全部替换掉，那么我们就需要使用ReplaceWith。
/// <summary>
/// QueryXml类
/// </summary>
public class QueryXml
{
/// <summary>
/// 返回xml文件路径
/// </summary>
public string Path
{
get
{
string path = @"....XmlReadWrite.xml";
return path;
}
}
/// <summary>
/// 替换xml指定节点
/// </summary>
public void ReplaceElement()
{
XElement xe = XElement.Load(Path);
var item = (from t in xe.Elements("Item")
where t.Value.Equals("Item2")
select t).FirstOrDefault();
if (item != null)
{
item.ReplaceWith(new XElement("Item", "Item3"));
}
xe.Save(Path);
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 替换xml指定节点
QueryXml xml = new QueryXml();
xml.ReplaceElement();
#endregion
}
}
最终生成的xml如下所示：
<?xml version="1.0" encoding="utf-8"?> <Root> <!--前面的注释--> <Item v1="1" v2="2">Item1</Item> <!--后面的注释--> <Item>Item3</Item> </Root>
2.6删除xml指定属性
前面我们介绍了创建、修改和添加属性，但是还没有介绍如何删除指定的属性，下面我们就通过一个简单的实例来演示。
/// <summary>
/// QueryXml类
/// </summary>
public class QueryXml
{
/// <summary>
/// 返回xml文件路径
/// </summary>
public string Path
{
get
{
string path = @"....XmlReadWrite.xml";
return path;
}
}
/// <summary>
/// 删除xml指定属性
/// </summary>
public void RemoveAttribute()
{
XElement xe = XElement.Load(Path);
var item = (from t in xe.Elements("Item")
where t.Value.Equals("Item1")
select t).FirstOrDefault().Attribute("v2");
if (item != null)
{
item.Remove();
}
xe.Save(Path);
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 删除xml指定属性
QueryXml xml = new QueryXml();
xml.RemoveAttribute();
#endregion
}
}
最终生成的xml如下所示：
<?xml version="1.0" encoding="utf-8"?> <Root> <!--前面的注释--> <Item v1="1">Item1</Item> <!--后面的注释--> <Item>Item3</Item> </Root>
2.7删除xml指定节点
既然上面已经可以删除属性，自然也少不了删除属性。
/// <summary>
/// QueryXml类
/// </summary>
public class QueryXml
{
/// <summary>
/// 返回xml文件路径
/// </summary>
public string Path
{
get
{
string path = @"....XmlReadWrite.xml";
return path;
}
}
/// <summary>
/// 删除xml指定节点
/// </summary>
public void RemoveElement()
{
XElement xe = XElement.Load(Path);
var item = (from t in xe.Elements("Item")
where t.Value.Equals("Item3")
select t).FirstOrDefault();
if (item != null)
{
item.Remove();
}
xe.Save(Path);
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 删除xml指定节点
QueryXml xml = new QueryXml();
xml.RemoveElement();
#endregion
}
}
最终生成的xml如下所示：
<?xml version="1.0" encoding="utf-8"?> <Root> <!--前面的注释--> <Item v1="1">Item1</Item> <!--后面的注释--> </Root>
三、按节点关系查询
上面的查询都是通过相关的条件进行查询，但是我们有时仅仅只需要通过之间的关系即可，这样反而可以避免很多的代码，当然稍加探索可以发现其
实XElement都提供给我们了。
创建一个Structure.xml文件：
<?xml version="1.0" encoding="utf-8" ?> <Root> <Item> <SubItem1> 1 </SubItem1> <SubItem> <Child> sss </Child> </SubItem> <SubItem2> 2 </SubItem2> </Item> </Root>
3.1显示xml指定节点的所有父节点
通过上面的xml文件，我们清晰的看出xml是具有结构性的，彼此之间都存在关系，而现在我们需要显示某个节点的父级节点的名称。
/// <summary>
/// StructureXml类
/// </summary>
public class StructureXml
{
public string Path
{
get
{
string path = string.Format(@"....Structure.xml");
return path;
}
}
/// <summary>
/// 显示xml指定节点的所有父节点
/// </summary>
public void ShowAllParentElement()
{
XElement xe = XElement.Load(Path);
var item = (from t in xe.Descendants("Child")
select t).FirstOrDefault();
if (item != null)
{
Console.WriteLine("----------------------------");
Console.WriteLine($"{item.Name}的向上父节点有：");
foreach (var upper in item.Ancestors())
{
Console.WriteLine(upper.Name);
}
Console.WriteLine("----------------------------");
Console.WriteLine($"{item.Name}及向上父节点有：");
foreach (var selfAndUpper in item.AncestorsAndSelf())
{
Console.WriteLine(selfAndUpper.Name);
}
Console.Read();
}
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 显示xml指定节点的所有父节点
StructureXml xml = new StructureXml();
xml.ShowAllParentElement();
#endregion
}
}
运行结果如下：
3.2显示xml指定节点的所有子节点
我们不仅仅可以输出一个节点的所有父级节点，同样也可以输出一个节点的所有子节点。
/// <summary>
/// StructureXml类
/// </summary>
public class StructureXml
{
public string Path
{
get
{
string path = string.Format(@"....Structure.xml");
return path;
}
}
/// <summary>
/// 显示xml指定节点的所有子节点
/// </summary>
public void ShowAllChildElement()
{
XElement xe = XElement.Load(Path);
Console.WriteLine("----------------------------");
foreach (var sub in xe.Descendants())
{
Console.WriteLine(sub.Name);
}
Console.WriteLine("----------------------------");
foreach (var sub in xe.DescendantsAndSelf())
{
Console.WriteLine(sub.Name);
}
Console.ReadKey();
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 显示xml指定节点的所有子节点
StructureXml xml = new StructureXml();
xml.ShowAllChildElement();
#endregion
}
}
运行结果如下：
3.3显示xml同级节点之前的节点
既然有了父子关系，当然也少不了同级关系，首先我们先显示同级节点之前的节点。
/// <summary>
/// StructureXml类
/// </summary>
public class StructureXml
{
public string Path
{
get
{
string path = string.Format(@"....Structure.xml");
return path;
}
}
/// <summary>
/// 显示xml同级节点之前的节点
/// </summary>
public void ShowPrevElement()
{
XElement xe = XElement.Load(Path);
var item = (from t in xe.Descendants("SubItem2")
select t).FirstOrDefault();
if (item != null)
{
Console.WriteLine($"与{item.Name}同级的前节点有：");
foreach (var sub in item.ElementsBeforeSelf())
{
Console.WriteLine(sub.Name);
}
}
Console.Read();
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 显示xml同级节点之前的节点
StructureXml xml = new StructureXml();
xml.ShowPrevElement();
#endregion
}
}
运行结果如下：
3.4显示xml同级节点之后的节点
/// <summary>
/// StructureXml类
/// </summary>
public class StructureXml
{
public string Path
{
get
{
string path = string.Format(@"....Structure.xml");
return path;
}
}
/// <summary>
/// 显示xml同级节点之后的节点
/// </summary>
public void ShowNextElement()
{
XElement xe = XElement.Load(Path);
var item = (from t in xe.Descendants("SubItem1")
select t).FirstOrDefault();
if (item != null)
{
Console.WriteLine($"与{item.Name}同级的后节点有：");
foreach (var sub in item.ElementsAfterSelf())
{
Console.WriteLine(sub.Name);
}
}
Console.Read();
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 显示xml同级节点之后的节点
StructureXml xml = new StructureXml();
xml.ShowNextElement();
#endregion
}
}
运行结果如下：
四、监听xml事件
你可能会疑惑xml为什么还要监听？其实这样是有意义的，比如你要根据某个节点的值作为依赖，那么你就要监听这个节点，如果这个节点发生改变
的时候，你才可以及时的作出反应。但是xml的事件监听有一个特点，跟浏览器中的DOM事件类似，监听父节点同样也可以监听的到它的子节点的事件。
下面我们通过一个简单的示例来说明：
/// <summary>
/// EventXml类
/// </summary>
public static class EventXml
{
public static void BindChangeing()
{
XElement xe = new XElement("Root");
xe.Changing += XElement_Changing;
xe.Changed += XElement_Changed;
//添加元素
xe.Add(new XElement("Item", "1"));
var item = xe.Element("Item");
//替换元素
item.ReplaceWith(new XElement("Item", "2"));
//删除元素
item = xe.Element("Item");
item.Remove();
//读取结果
Console.Read();
}
static void XElement_Changing(object sender, XObjectChangeEventArgs e)
{
XElement xe = sender as XElement;
Console.WriteLine($"{xe.Name}正在进行{e.ObjectChange}操作中，sender={sender.ToString()}。");
}
static void XElement_Changed(object sender, XObjectChangeEventArgs e)
{
XElement xe = sender as XElement;
Console.WriteLine($"{xe.Name}已完成{e.ObjectChange}操作，sender={sender.ToString()}。
");
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 监听xml事件
EventXml.BindChangeing();
#endregion
}
}
运行结果如下：
五、处理xml流
在实际的商业化的开发中，xml不可能仅仅保存这么点数据，有可能保存着非常多的数据。假如我们还是按照以往的方式，就会将xml全部读取进内
存，这样会占用非常多的内存从而影响系统的性能。针对这种情况我们需要使用流的方式去处理xml，因为流会按照我们的顺序读取部分xml进内存，
并不会将所有xml都读取到内存中。
创建一个Stream.xml文件：
<?xml version="1.0" encoding="utf-8" ?> <Root> <SubItem>1</SubItem> <SubItem>1</SubItem> <SubItem>1</SubItem> <Item>A</Item> <SubItem>1</SubItem> <Item>B</Item> </Root>
这里我们通过XmlReader的Create静态方法打开xml文件，并通过Read一个节点的进行读取，并判断该节点的类型。
/// <summary>
/// ReadXmlStream类
/// </summary>
public static class ReadXmlStream
{
public static string Path
{
get
{
string path = @"....Stream.xml";
return path;
}
}
/// <summary>
/// 流式处理XML
/// </summary>
public static void ReadXml()
{
XmlReader reader = XmlReader.Create(Path);
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element && reader.Name.Equals("Item"))
{
XElement xe = XNode.ReadFrom(reader) as XElement;
Console.WriteLine(xe.Value.Trim());
}
}
Console.Read();
}
}
class Program
{
static void Main(string[] args)
{
#region LINQ 处理xml流
ReadXmlStream.ReadXml();
#endregion
}
}
运行结果如下：
栏目列表
最新更新
nodejs爬虫
Python正则表达式完全指南
爬取豆瓣Top250图书数据
shp 地图文件批量添加字段
爬虫小试牛刀（爬取学校通知公告）
【python基础】函数-初识函数
【python基础】函数-返回值
HTTP请求：requests模块基础使用必知必会
Python初学者友好丨详解参数传递类型
如何有效管理爬虫流量？
SQL SERVER中递归
2个场景实例讲解GaussDB(DWS)基表统计信息估
常用的 SQL Server 关键字及其含义
动手分析SQL Server中的事务中使用的锁
openGauss内核分析：SQL by pass & 经典执行
一招教你如何高效批量导入与更新数据
天天写SQL，这些神奇的特性你知道吗？
openGauss内核分析：执行计划生成
[IM002]Navicat ODBC驱动器管理器 未发现数据
初入Sql Server 之 存储过程的简单使用
这是目前我见过最好的跨域解决方案！
减少回流与重绘
减少回流与重绘
如何使用KrpanoToolJS在浏览器切图
performance.now() 与 Date.now() 对比
一款纯 JS 实现的轻量化图片编辑器
关于开发 VS Code 插件遇到的 workbench.scm.
前端设计模式——观察者模式
前端设计模式——中介者模式
创建型-原型模式