C# 使用c语言从xml片段形成格式良好的xml#

我正在从一个循环中构造xmlnodes。所以它的作用是

   var settings = new XmlWriterSettings();
   settings.OmitXmlDeclaration = true;
   settings.Indent = true;
   var ns = new XmlSerializerNamespaces();
   ns.Add("", "");
   foreach (Person human in bar)
    {
        var serializer = new XmlSerializer(typeof(Person));
        using (var stream = new FileStream(filepath, FileMode.Append))
        using (var writer = XmlWriter.Create(stream, settings))
        {
            serializer.Serialize(writer, human, ns);
        }
    }

当循环完成时，它形成xml片段，输出xml如下

    <Person>
  <Name>mar8a</Name>
  <Age>11</Age>
  <Sex>MALE</Sex>
  <Address>TOP 92 BOTTOM</Address>
  <SingleYn>false</SingleYn>
</Person>
<Person>
  <Name>mar1a</Name>
  <Age>1</Age>
  <Sex>MALE</Sex>
  <Address>TOP 92 BOTTOM</Address>
  <SingleYn>false</SingleYn>
</Person>
<Person>
  <Name>mar2a</Name>
  <Age>11</Age>
  <Sex>MALE</Sex>
  <Address>TOP 92 BOTTOM</Address>
  <SingleYn>false</SingleYn>
</Person>
<Person>
  <Name>mar3a</Name>
  <Age>1</Age>
  <Sex>MALE</Sex>
  <Address>TOP 92 BOTTOM</Address>
  <SingleYn>false</SingleYn>
</Person><Person>
  <Name>mar4a</Name>
  <Age>11</Age>
  <Sex>MALE</Sex>
  <Address>TOP 92 BOTTOM</Address>
  <SingleYn>false</SingleYn>
</Person>
<Person>
  <Name>mar5a</Name>
  <Age>11</Age>
  <Sex>MALE</Sex>
  <Address>TOP 92 BOTTOM</Address>
  <SingleYn>false</SingleYn>
</Person>
<Person>
  <Name>mar6a</Name>
  <Age>11</Age>
  <Sex>MALE</Sex>
  <Address>TOP 92 BOTTOM</Address>
  <SingleYn>false</SingleYn>
</Person>
<Person>
  <Name>mar7a</Name>
  <Age>11</Age>
  <Sex>MALE</Sex>
  <Address>TOP 92 BOTTOM</Address>
  <SingleYn>false</SingleYn>
</Person>
<Person>
  <Name>mar8a</Name>
  <Age>11</Age>
  <Sex>MALE</Sex>
  <Address>TOP 92 BOTTOM</Address>
  <SingleYn>false</SingleYn>
</Person>

mar8a
11
男性
顶部92底部
假的
mar1a
1.
男性
顶部92底部
假的
mar2a
11
男性
顶部92底部
假的
mar3a
1.
男性
顶部92底部
假的
mar4a
11
男性
顶部92底部
假的
mar5a
11
男性
顶部92底部
假的
mar6a
11
男性
顶部92底部
假的
mar7a
11
男性
顶部92底部
假的
mar8a
11
男性
顶部92底部
假的

我正在运行的问题是如何修改它，并使其成为一个格式良好的xml，在循环结束时具有根节点和声明

我尝试了下面的概念，但运气不好，因为它限制了我在作者身上不写任何根元素

        StringBuilder output = new StringBuilder();
        XmlReaderSettings ws = new XmlReaderSettings();
        ws.ConformanceLevel = ConformanceLevel.Fragment;
        String xmlString =
                @"<Item>test with a child element stuff</Item>
                <Item>test with a child element stuff</Item>";
        // Create an XmlReader
        using (XmlReader reader = XmlReader.Create(new StringReader(xmlString), ws))
        {
            XmlWriterSettings ws2 = new XmlWriterSettings();
            ws2.Indent = true;
            using (XmlWriter writer = XmlWriter.Create(output, ws2))
            {
                writer.WriteStartDocument();
                // Parse the file and display each of the nodes.
                while (reader.Read())
                {
                    switch (reader.NodeType)
                    {
                        case XmlNodeType.Element:
                            writer.WriteStartElement(reader.Name);
                            break;
                        case XmlNodeType.Text:
                            writer.WriteString(reader.Value);
                            break;
                        case XmlNodeType.XmlDeclaration:
                        case XmlNodeType.ProcessingInstruction:
                            writer.WriteProcessingInstruction(reader.Name, reader.Value);
                            break;
                        case XmlNodeType.Comment:
                            writer.WriteComment(reader.Value);
                            break;
                        case XmlNodeType.EndElement:
                            writer.WriteFullEndElement();
                            break;
                    }
                }
                writer.WriteEndDocument();

            }
        }

StringBuilder输出=新建StringBuilder（）；
XmlReaderSettings ws=新的XmlReaderSettings（）；
ws.ConformanceLevel=ConformanceLevel.Fragment；
字符串xmlString=
@“使用子元素进行测试。”
使用子元素“stuff”进行测试；
//创建一个XmlReader
使用（XmlReader=XmlReader.Create（新的StringReader（xmlString），ws））
{
XmlWriterSettings ws2=新的XmlWriterSettings（）；
ws2.Indent=true；
使用（XmlWriter=XmlWriter.Create（输出，ws2））
{
writer.WriteStartDocument（）；
//解析文件并显示每个节点。
while（reader.Read（））
{
开关（reader.NodeType）
{
case XmlNodeType.Element：
writer.writeStart元素（reader.Name）；
打破
案例XmlNodeType.Text：
writer.WriteString（reader.Value）；
打破
案例XmlNodeType.XmlDeclaration：
案例XmlNodeType.ProcessingInstruction：
writer.WriteProcessingInstruction（reader.Name，reader.Value）；
打破
案例XmlNodeType.Comment：
writer.WriteComment（reader.Value）；
打破
案例XmlNodeType.EndElement：
writer.writeFileLendElement（）；
打破
}
}
writer.WriteEndDocument（）；
}
}

更新

下面是序列化我的序列化程序实现的列表的代码

        public static async Task WriteXMLAsync<T>(this List<T> listRows, T entity, VMEXPORT[] arrVmExport, string filePath)
        where T : class
    {
        XmlWriterSettings Xmlsettings = new XmlWriterSettings();
        Xmlsettings.Indent = true;
        Xmlsettings.OmitXmlDeclaration = false;
        Xmlsettings.NewLineOnAttributes = true;
        Xmlsettings.Async = true;
        Xmlsettings.Encoding = Encoding.UTF8;
        Xmlsettings.CheckCharacters = false;

        XmlAttributeOverrides Xmloverrides = new XmlAttributeOverrides();
        XmlAttributes Xmlattribs = new XmlAttributes();
        Xmlattribs.XmlIgnore = true;
        Xmlattribs.XmlElements.Add(new XmlElementAttribute("SfiObjectState"));
        Xmloverrides.Add(typeof(T), "SfiObjectState", Xmlattribs);


        if (!File.Exists(filePath))
        {
            using (var fileStream = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None, 4096, true))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(List<T>), Xmloverrides);
                using (XmlWriter xmlWriter = XmlWriter.Create(fileStream, Xmlsettings))
                {
                    serializer.Serialize(xmlWriter, listRows);
                    await xmlWriter.FlushAsync();
                }
            }
        }
        else
        {

            using (var fileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.None, 4096, true))
            {
                XmlSerializer serializer = new XmlSerializer(typeof(List<T>), Xmloverrides);
                using (XmlWriter xmlWriter = XmlWriter.Create(fileStream, Xmlsettings))
                {
                    serializer.Serialize(xmlWriter, listRows);
                    await xmlWriter.FlushAsync();
                }
            }


        }

    }

public static async Task WriteXMLAsync（此列表列出行、T实体、VMEXPORT[]arrVmExport、字符串文件路径）
T:在哪里上课
{
XmlWriterSettings=新的XmlWriterSettings（）；
Xmlsettings.Indent=true；
Xmlsettings.ommitXMLDeclaration=false；
Xmlsettings.NewLineOnAttributes=true；
Xmlsettings.Async=true；
Xmlsettings.Encoding=Encoding.UTF8；
Xmlsettings.CheckCharacters=false；
XmlAttributeOverrides Xmloverrides=新的XmlAttributeOverrides（）；
XmlAttributes Xmlattribs=新的XmlAttributes（）；
Xmlattribs.XmlIgnore=true；
添加（新的XmlElementAttribute（“SfiObjectState”）；
Add（typeof（T），“SfiObjectState”，Xmlattribs）；
如果（！File.Exists（filePath））
{
使用（var fileStream=newfilestream（filePath，FileMode.OpenOrCreate，FileAccess.Write，FileShare.None，4096，true））
{
XmlSerializer serializer=新的XmlSerializer（类型（列表），Xmloverrides）；
使用（XmlWriter=XmlWriter.Create（fileStream，Xmlsettings））
{
serializer.Serialize（xmlWriter，listRows）；
等待xmlWriter.FlushAsync（）；
}
}
}
其他的
{
使用（var fileStream=newfilestream（filePath，FileMode.Append，FileAccess.Write，FileShare.None，4096，true））
{
XmlSerializer serializer=新的XmlSerializer（类型（列表），Xmloverrides）；
使用（XmlWriter=XmlWriter.Create（fileStream，Xmlsettings））
{
serializer.Serialize（xmlWriter，listRows）；
等待xmlWriter.FlushAsync（）；
}
}
}
}

下面是对上述方法的迭代，实现take和skip

 public async Task WriteXmlDataAsync<TEntity>(IQueryable<TEntity> listToWrite, [DataSourceRequest]DataSourceRequest dataRequest,
                                          int countno, VMEXPORT[] vmExportarr, CancellationToken token,
                                          TEntity entity, string csvFileNametx, string XmlFilePathtx)
      where TEntity : class
    {
        dataRequest.GroupingToSorting();
        int datapageno = (countno / GeneralConst.L_MAX_EXPORT_REC) + 1;
        for (int ctrno = 1; ctrno <= datapageno; )
        {
            if (token.IsCancellationRequested)
            {
                RemoveTask(csvFileNametx);
                token.ThrowIfCancellationRequested();
            }
            dataRequest.Page = ctrno;
            dataRequest.PageSize = GeneralConst.L_MAX_EXPORT_REC;
            var dataSourceResult = listToWrite.ToDataSourceResult(dataRequest);
            await dataSourceResult.Data.Cast<TEntity>().ToList().WriteXMLAsync(entity, vmExportarr, XmlFilePathtx);
            ctrno = ctrno + 1;
            int percentageno = (ctrno * 100) / datapageno;
            if (percentageno > 100) percentageno = 100;
            UpdateTask(csvFileNametx, percentageno);
        }

    }

public async Task WriteXmlDataAsync（IQueryable listToWrite，[DataSourceRequest]DataSourceRequest dataRequest，
int countno，VMEXPORT[]vmExportarr，CancellationToken令牌，
TEntity实体，字符串csvFileNametx，字符串XmlFilePathtx）
地点：班级
{
dataRequest.GroupingToSorting（）；
int datapageno=（countno/GeneralConst.L\u MAX\u EXPORT\u REC）+1；
对于（int ctrno=1；ctrno 100）百分比AGENO=100；
更新任务（csvFileNametx，percentageno）；
}
}

试试下面的方法。您还需要在根级别上只有一个级别的标记

            XmlDocument doc = new XmlDocument();
            doc.LoadXml(xmlStr);


            XmlDeclaration xDeclare = doc.CreateXmlDeclaration("1.0", "UTF-8", null);
            XmlNode docNode = doc.CreateXmlDeclaration("1.0", "UTF-8", null);

            doc.InsertBefore(xDeclare, doc.FirstChild);

            //or
            string xml1 ="<Root>" + "Your XML" + "</Root>";

            //or
            string xml2 = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><Root>" + "Your XML" + "</Root>"; 
​

XmlDocument doc=新的XmlDocument（）；
doc.LoadXml（xmlStr）；
XmlDeclaration xDeclare=doc.CreateXmlDeclaration（“1.0”，“UTF-8”，null）；
XmlNode docNode=doc.CreateXmlDeclaration（“1.0”，“UTF-8”，null）；
文档InsertBefore（xDeclare，文档FirstChild）；
//或
字符串xml1=“”+”您的XML“+”；
//或
字符串xml2=“”+”您的XML“+”；
​

选项1

在编写XML文件后，您可以快速执行以下操作：

    public static void AddOuterElement(string fileName, string elementName)
    {
        var startElement = string.Format(@"<{0}>", elementName);
        var endElement = string.Format(@"</{0}>", elementName);

        var tmpName = Path.GetTempFileName();
        try
        {
            using (var writer = new StreamWriter(tmpName, false, Encoding.UTF8))
            {
                writer.WriteLine(startElement);
                foreach (var line in File.ReadLines(fileName))  // Reads lines incrementally rather than all at once.
                    writer.WriteLine(line);
                writer.WriteLine(endElement);
            }
        }
        catch (Exception ex)
        {
            Debug.WriteLine(ex);
            try
            {
                System.IO.File.Delete(tmpName);
            }
            catch (Exception)
            {
            }
            throw;
        }
        System.IO.File.Delete(fileName);
        System.IO.File.Move(tmpName, fileName);
    }

<

    IEnumerable<IEnumerable<Person>> GetPeopleInChunks()
    {
        // Query the database in chunks of 200 and yield return each list.
    }

// Proxy class for any enumerable with the requisite `Add` methods.
public class EnumerableProxy<T> : IEnumerable<T>
{
    [XmlIgnore]
    public IEnumerable<T> BaseEnumerable { get; set; }

    public void Add(T obj)
    {
        throw new NotImplementedException();
    }

    #region IEnumerable<T> Members

    public IEnumerator<T> GetEnumerator()
    {
        if (BaseEnumerable == null)
            return Enumerable.Empty<T>().GetEnumerator();
        return BaseEnumerable.GetEnumerator();
    }

    #endregion

    #region IEnumerable Members

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    #endregion
}

[XmlRoot("People")]
public class People
{
    [XmlIgnore]
    public IEnumerable<Person> Results { get; set; }

    [XmlElement("Person")]
    public EnumerableProxy<Person> ResultsProxy
    {
        get
        {
            return new EnumerableProxy<Person> { BaseEnumerable = Results };
        }
        set
        {
            throw new NotImplementedException();
        }
    }
}

    public void WriteXml(string fileName)
    {
        var people = new People { Results = GetPeopleInChunks().SelectMany(chunk => chunk) };
        using (var writer = XmlWriter.Create(fileName))
        {
            new XmlSerializer(typeof(People)).Serialize(writer, people);
        }
    }

    XmlDocument oXmlDocument = new XmlDocument();
    oXmlDocument.AppendChild(oXmlDocument.CreateXmlDeclaration("1.0", "UTF-8", ""));

    string sFileContents = "XML Fragments In Here";

    XmlNode oRootXmlNode = oXmlDocument.CreateElement("Root");
    oRootXmlNode.InnerXml = sFileContents;

    oXmlDocument.AppendChild(oRootXmlNode);
    oXmlDocument.Save("XMLFileName.xml");