本文将为您提供关于LINQ读取XML的详细介绍，我们还将为您解释linux读取xml文件内容的相关知识，同时，我们还将为您提供关于.net–XML序列化与LINQtoXML、.net–如何使用LINQ
本文将为您提供关于LINQ 读取 XML的详细介绍，我们还将为您解释linux读取xml文件内容的相关知识，同时，我们还将为您提供关于.net – XML序列化与LINQ to XML、.net – 如何使用LINQ to XML读取/写入加密的XML文件？、C# Linq 如何通过流读取 xml 并过滤特定元素、C# LINQ学习笔记五：LINQ to XML的实用信息。
本文目录一览：- LINQ 读取 XML（linux读取xml文件内容）
- .net – XML序列化与LINQ to XML
- .net – 如何使用LINQ to XML读取/写入加密的XML文件？
- C# Linq 如何通过流读取 xml 并过滤特定元素
- C# LINQ学习笔记五：LINQ to XML
LINQ 读取 XML（linux读取xml文件内容）
我得到了这个 XML 文件：
<root>
<level1 name="A">
<level2 name="A1" />
<level2 name="A2" />
</level1>
<level1 name="B">
<level2 name="B1" />
<level2 name="B2" />
</level1>
<level1 name="C" />
</root>
有人可以给我一个使用 LINQ 的 C# 代码，打印这个结果的最简单方法：（如果它是一个节点
，请注意额外的空间）level2
A
A1
A2
B
B1
B2
C
目前我得到了这个代码：
XDocument xdoc = XDocument.Load("data.xml"));
var lv1s = from lv1 in xdoc.Descendants("level1")
select lv1.Attribute("name").Value;
foreach (var lv1 in lv1s)
{
result.AppendLine(lv1);
var lv2s = from lv2 in xdoc...???
}
.net – XML序列化与LINQ to XML
我对
XML序列化和LINQ to
XML几乎没有任何疑问.
我们什么时候使用XML Serialization和LINQ to XML？请指定使用XML Serialziation和LINQ to XML的情况或场景的类型.
XML Serialization和LINQ to XML之间有什么区别？
使用XML Serialziation而不是LINQ to XML有什么好处,反之亦然.
我在msdn和各种关于DOM和LINQ to XML的博客中读过但是找不到有关XML Serialization vs LINQ to XML的更多信息.如果我们能够利用优点和缺点来整合.NET中的所有XML方法,那就太棒了.
感谢您的帮助.
问候,
Sushma
解决方法
他们是完全不同的东西：
> XML序列化允许您获取整个对象的XML表示形式,并将其转换回对象.当您需要存储对象的当前状态或将其传输到远程位置时,可以使用它.> LINQ to XML(或.NET框架的XML类)用于生成和处理“按原样”获取的XML文件,而不是直接映射到对象,例如来自RSS提要的数据.
.net – 如何使用LINQ to XML读取/写入加密的XML文件？
我想使用LINQ to
XML读/写加密的
XML文件.有谁知道如何使用.NET Framework内置的加密算法来加密XDocument对象使用的Stream？
我确实尝试过,但你不能将CryptoStream设置为读/写访问权限.它只支持Read或Write,这会导致LINQ to XML抛出异常.
更新：“动态”读取/写入文档会很好,但我只需要读取加密的xml文件,对其进行操作,然后再将其写回加密.
解决方法
最简单的方法可能是XDocument.Load(),Linq,然后是XDocument.Save().从快速测试应用程序(轻松使用非处置资源)：
XDocument writeContacts = new XDocument(
new XElement("contacts",new XElement("contact",new XElement("name","Patrick Hines"),new XElement("phone","206-555-0144",new XAttribute("type","home")),"425-555-0145","work")),new XElement("address",new XElement("street1","123 Main St"),new XElement("city","Mercer Island"),new XElement("state","WA"),new XElement("postal","68042")
)
)
)
);
Rijndael RijndaelAlg = Rijndael.Create();
FileStream writeStream = File.Open("data.xml",FileMode.Create);
CryptoStream cStream = new CryptoStream(writeStream,RijndaelAlg.CreateEncryptor(RijndaelAlg.Key,RijndaelAlg.IV),CryptoStreamMode.Write);
StreamWriter writer = new StreamWriter(cStream);
writeContacts.Save(writer);
writer.Flush();
writer.Close();
FileStream readStream = File.OpenRead("data.xml");
cStream = new CryptoStream(readStream,RijndaelAlg.CreateDecryptor(RijndaelAlg.Key,CryptoStreamMode.Read);
XmlTextReader reader = new XmlTextReader(cStream);
XDocument readContacts = XDocument.Load(reader);
//manipulate with Linq and Save() when needed
将您最喜欢的ICryptoTransform交换到CryptoStream中.
C# Linq 如何通过流读取 xml 并过滤特定元素
如何解决C# Linq 如何通过流读取 xml 并过滤特定元素？
我是 C# Linq to XML 的新手。我正在尝试读取 XML 文件并查询有多少元素，例如：在我的案例中居住在伦敦地址的客户。从下面的 xml 我想检索客户 A 和 D。
<?xml version="1.0" encoding="UTF-8"?>
<Message xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="SFA/LR/2020-21" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="SFA/LR/2020-21">
<Header>This is header</Header>
<SourceFiles>This is another element</SourceFiles>
<Customer>
<Name>Customer A</Name>
<Age>23</Age>
<Address>
<City>London</City>
</Address>
</Customer>
<Customer>
<Name>Customer B</Name>
<Age>23</Age>
<Address>
<City>New York</City>
</Address>
</Customer>
<Customer>
<Name>Customer C</Name>
<Age>23</Age>
<Address>
<City>Chennai</City>
</Address>
</Customer>
<Customer>
<Name>Customer D</Name>
<Age>23</Age>
<Address>
<City>London</City>
</Address>
</Customer>
</Message
我在 C# 中尝试过如下但没有工作。当我为每个元素命名空间属性使用下面的代码时，会附加 ile。 <Customer xmlns="SFA/LR/2020-21"....因此我无法过滤 root.Elements()。
private int GetValidCustomers(MemoryStream targetStream)
{
targetStream.Position = 0;
XElement root = XElement.Load(targetStream);
IEnumerable<XElement> customersList = root.Elements().Select(el => el.Name == ''Customer'');
}
解决方法
暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！
如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。
小编邮箱:dio#foxmail.com (将#修改为@）
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()}。\n");
}
}
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
}
}运行结果如下：
今天关于LINQ 读取 XML和linux读取xml文件内容的分享就到这里，希望大家有所收获，若想了解更多关于.net – XML序列化与LINQ to XML、.net – 如何使用LINQ to XML读取/写入加密的XML文件？、C# Linq 如何通过流读取 xml 并过滤特定元素、C# LINQ学习笔记五：LINQ to XML等相关知识，可以在本站进行查询。
本文标签：
