C#解析命名空间中的项

我有以下XML：

我想将项目值与字段值匹配

XmlDocument xdoc = new XmlDocument();
xdoc.Load(ofd.FileName);

XmlNamespaceManager xmanager = new XmlNamespaceManager(xdoc.NameTable);
xmanager.AddNamespace("ns", "http://www.canto.com/ns/Export/1.0");

var result = xdoc.SelectNodes("//ns:Layout/ns:Fields", xmanager);
foreach(XmlElement item in result)
{
    Console.WriteLine(item.InnerText);

}

---

当我这样做时，我会在一行中得到所有字段名。如何遍历布局中的所有字段并逐个执行？

我使用xml linq解析xml。首先，我把项目放入字典。然后我解析字段，从字典中查找uid。我递归地解析字段以保持层次结构

看起来每个项目的uid、类型、值和名称都是相同的，但是一个项目可以出现在多个目录中，并具有目录id和id

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

namespace ConsoleApplication1
{
    class Program
    {
        const string FILENAME = @"c:\temp\test.xml";

        static void Main(string[] args)
        {
            Layout layout = new Layout(FILENAME);
        }
    }
    public class Layout
    {
        public string tablename { get; set; }
        public List<Field> fields { get; set; }
        public Layout layout { get; set; }
        public Dictionary<string, Item> dict = new Dictionary<string, Item>();

        public Layout() { }
        public Layout(string filename)
        {
            XDocument doc = XDocument.Load(filename);

            XElement xLayout = doc.Descendants().Where(x => x.Name.LocalName == "Layout").FirstOrDefault();
            XNamespace ns = xLayout.GetNamespaceOfPrefix("ns");

            foreach (XElement item in doc.Descendants(ns + "Item"))
            {
                int catalogid = (int)item.Attribute("catalogid");
                int id = (int)item.Attribute("id");

                foreach(XElement fieldValue in item.Elements(ns + "FieldValue"))
                {
                    string uid = (string)fieldValue.Attribute("uid");
                    uid = uid.Replace("{", "");
                    uid = uid.Replace("}", "");
                    string innertext = (string)fieldValue;
                    string displayValue = (string)fieldValue.Attribute("displayValue");
                    List<string> categoryValues = fieldValue.Elements(ns + "CategoryValue").Select(x => (string)x).ToList();
                    if (!dict.ContainsKey(uid))
                    {
                        Item newItem = new Item() { 
                            catalogidId = new List<KeyValuePair<int, int>>() {new KeyValuePair<int, int>(catalogid, id)}, 
                            innertext = innertext, 
                            uid = uid,
                            displayValue = displayValue,
                            categoryValues = categoryValues
                        };
                        dict.Add(uid, newItem);
                    }
                    else
                    {
                       dict[uid].catalogidId.Add(new KeyValuePair<int, int>(catalogid, id));
                    }
                }
            }

            layout = new Layout();


            RecursiveParse(ns, xLayout, layout);


        }
        public void RecursiveParse(XNamespace ns, XElement parent, Layout layout)
        {
            layout.tablename = (string)parent.Attribute("tableName");
            foreach(XElement xField in parent.Element(ns + "Fields").Elements(ns + "Field"))
            {
                if (layout.fields == null) layout.fields = new List<Field>();

                Field newField = new Field();
                layout.fields.Add(newField);
                newField.uid = (string)xField.Attribute("uid");
                newField.uid = newField.uid.Replace("{", "");
                newField.uid = newField.uid.Replace("}", "");
                newField._type = (int)xField.Attribute("type");
                newField.value = (int)xField.Attribute("valueInterpretation");
                newField.name = (string)xField.Element(ns + "Name");
                if (dict.ContainsKey(newField.uid))
                {
                    newField.items = dict[newField.uid];
                }

                if (xField.Element(ns + "Layout") != null)
                {
                    Layout newLayout = new Layout();
                    newField.layout = newLayout;
                    RecursiveParse(ns, xField.Element(ns + "Layout"), newLayout);
                }

            }
        }


        public class Field
        {
            public string uid { get; set; }
            public int _type { get; set; }
            public int value { get; set; }
            public string name { get; set; }
            public Layout layout { get; set; }
            public Item items { get; set; }
        }
        public class Item
        {
            public List<KeyValuePair<int, int>> catalogidId { get; set; }
            public string uid { get; set; }
            public string innertext { get; set; }
            public string displayValue { get; set; }
            public List<string> categoryValues { get; set; }
        }

    }

}

使用系统；
使用System.Collections.Generic；
使用System.Linq；
使用系统文本；
使用System.IO；
使用System.Xml；
使用System.Xml.Linq；
命名空间控制台应用程序1
{
班级计划
{
常量字符串文件名=@“c:\temp\test.xml”；
静态void Main（字符串[]参数）
{
布局=新布局（文件名）；
}
}
公共班级布局
{
公共字符串表名{get；set；}
公共列表字段{get；set；}
公共布局{get；set；}
公共字典dict=新字典（）；
公共布局（）{}
公共布局（字符串文件名）
{
XDocument doc=XDocument.Load（文件名）；
XElement xLayout=doc.subjects（）。其中（x=>x.Name.LocalName==“Layout”）.FirstOrDefault（）；
XNamespace ns=xLayout.GetNamespaceOfPrefix（“ns”）；
foreach（文档子体中的XElement项（ns+“项”））
{
int catalogid=（int）item.Attribute（“catalogid”）；
int id=（int）item.Attribute（“id”）；
foreach（item.Elements中的XElement字段值（ns+“字段值”））
{
字符串uid=（字符串）fieldValue.Attribute（“uid”）；
uid=uid.Replace（“{，”）；
uid=uid.Replace（“}”和“”）；
字符串innertext=（字符串）字段值；
字符串displayValue=（字符串）fieldValue.Attribute（“displayValue”）；
列出categoryValues=fieldValue.Elements（ns+“CategoryValue”）。选择（x=>（字符串）x.ToList（）；
如果（！dict.ContainsKey（uid））
{
Item newItem=newItem（）{
catalogidId=new List（）{new KeyValuePair（catalogid，id）}，
innertext=innertext，
uid=uid，
displayValue=displayValue，
类别价值=类别价值
};
dict.Add（uid，newItem）；
}
其他的
{
dict[uid].catalogidd.Add（新的键值对（catalogid，id））；
}
}
}
布局=新布局（）；
递归解析（ns、xLayout、布局）；
}
公共void RecursiveParse（XNS名称空间、XElement父级、布局）
{
layout.tablename=（字符串）parent.Attribute（“tablename”）；
foreach（父.Element（ns+“字段”）.Elements（ns+“字段”）中的XElement xField）
{
如果（layout.fields==null）layout.fields=new List（）；
字段newField=新字段（）；
layout.fields.Add（newField）；
newField.uid=（字符串）xField.Attribute（“uid”）；
newField.uid=newField.uid.Replace（“{，”）；
newField.uid=newField.uid.Replace（“}”和“”）；
newField._type=（int）xField.Attribute（“type”）；
newField.value=（int）xField.Attribute（“值解释”）；
newField.name=（字符串）xField.Element（ns+“name”）；
if（dict.ContainsKey（newField.uid））
{
newField.items=dict[newField.uid]；
}
if（xField.Element（ns+“布局”）！=null）
{
布局newLayout=新布局（）；
newField.layout=newLayout；
递归解析（ns，xField.Element（ns+“布局”），newLayout；
}
}
}
公共类字段
{
公共字符串uid{get；set；}
公共整型{get；set；}
公共int值{get；set；}
公共字符串名称{get；set；}
公共布局{get；set；}
公共项项{get；set；}
}
公共类项目
{
公共列表catalogidId{get；set；}
公共字符串uid{get；set；}
公共字符串innertext{get；set；}
公共字符串显示值{get；set；}
公共列表类别值{get；set；}
}
}
}

请在问题中添加XML片段。问题是，最终pastebin将消失，使您的问题成为孤儿。将其直接添加到问题中可以确保您的问题具有持久的价值。我对此没有太多经验，但如果您想要单个字段，您不应该搜索

//ns:Layout/ns:Fields/:ns:Field

。我猜您的版本只找到了

标记，而不是嵌套的

标记。我会添加XML示例，但它非常大，无法粘贴。我将尝试此方法。非常感谢。