C# 自定义xmlWriter是否跳过某个元素？

我正在实现一个自定义xmlwriter，我想省略任何具有特定名称的元素，如

我该怎么做呢？我感觉可能需要像这样覆盖

writeStarteElement

方法：

public override void WriteStartElement(string prefix, string localName, string ns)
{

    if (localName.Equals("ABC")) 
    {
        return;
    }
    base.WriteStartElement(prefix, localName, ns);
}

---

我是否还需要覆盖

writeedelement

方法？如何告诉

writeedelement

方法跳过写入end

标记？在我可以检查的

writeedelement

方法中似乎没有引用

localName

。？

在我之前编写的一些示例代码中发现了这一点。它维护一个下推堆栈，以确定是否写入元素结尾，这是您需要执行的操作：

public class ElementSkippingXmlTextWriter : XmlWriterProxy
{
    readonly Stack<bool> stack = new Stack<bool>();
    readonly Func<string, string, int, bool> filter;
    readonly Func<string, string, int, string> nameEditor;
    readonly bool filterChildren;

    public ElementSkippingXmlTextWriter(XmlWriter writer, Func<string, string, int, bool> filter, bool filterChildren)
        : this(writer, filter, null, filterChildren)
    {
    }

    public ElementSkippingXmlTextWriter(XmlWriter writer, Func<string, string, int, bool> filter, Func<string, string, int, string> nameEditor, bool filterChildren)
        : base(writer)
    {
        this.filter = filter ?? delegate { return true; };
        this.nameEditor = nameEditor ?? delegate(string localName, string ns, int depth) { return localName; };
        this.filterChildren = filterChildren;
    }

    protected override bool IsSuspended
    {
        get
        {
            if (filterChildren)
            {
                if (!stack.All(b => b))
                    return true;
            }
            else
            {
                if (stack.Count > 0 && !stack.Peek())
                    return true;
            }

            return base.IsSuspended;
        }
    }

    public override void WriteStartElement(string prefix, string localName, string ns)
    {
        var write = filter(localName, ns, stack.Count);
        var newLocalName = nameEditor(localName, ns, stack.Count);
        if (write)
            base.WriteStartElement(prefix, newLocalName, ns);
        stack.Push(write);
    }

    public override void WriteEndElement()
    {
        if (stack.Pop())
            base.WriteEndElement();
    }
}

public class XmlWriterProxy : XmlWriter
{
    readonly XmlWriter baseWriter;

    public XmlWriterProxy(XmlWriter baseWriter)
    {
        if (baseWriter == null)
            throw new ArgumentNullException();
        this.baseWriter = baseWriter;
    }

    protected virtual bool IsSuspended { get { return false; } }

    public override void Close()
    {
        baseWriter.Close();
    }

    public override void Flush()
    {
        baseWriter.Flush();
    }

    public override string LookupPrefix(string ns)
    {
        return baseWriter.LookupPrefix(ns);
    }

    public override void WriteBase64(byte[] buffer, int index, int count)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteBase64(buffer, index, count);
    }

    public override void WriteCData(string text)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteCData(text);
    }

    public override void WriteCharEntity(char ch)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteCharEntity(ch);
    }

    public override void WriteChars(char[] buffer, int index, int count)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteChars(buffer, index, count);
    }

    public override void WriteComment(string text)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteComment(text);
    }

    public override void WriteDocType(string name, string pubid, string sysid, string subset)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteDocType(name, pubid, sysid, subset);
    }

    public override void WriteEndAttribute()
    {
        if (IsSuspended)
            return;
        baseWriter.WriteEndAttribute();
    }

    public override void WriteEndDocument()
    {
        if (IsSuspended)
            return;
        baseWriter.WriteEndDocument();
    }

    public override void WriteEndElement()
    {
        if (IsSuspended)
            return;
        baseWriter.WriteEndElement();
    }

    public override void WriteEntityRef(string name)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteEntityRef(name);
    }

    public override void WriteFullEndElement()
    {
        if (IsSuspended)
            return;
        baseWriter.WriteFullEndElement();
    }

    public override void WriteProcessingInstruction(string name, string text)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteProcessingInstruction(name, text);
    }

    public override void WriteRaw(string data)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteRaw(data);
    }

    public override void WriteRaw(char[] buffer, int index, int count)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteRaw(buffer, index, count);
    }

    public override void WriteStartAttribute(string prefix, string localName, string ns)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteStartAttribute(prefix, localName, ns);
    }

    public override void WriteStartDocument(bool standalone)
    {
        baseWriter.WriteStartDocument(standalone);
    }

    public override void WriteStartDocument()
    {
        baseWriter.WriteStartDocument();
    }

    public override void WriteStartElement(string prefix, string localName, string ns)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteStartElement(prefix, localName, ns);
    }

    public override WriteState WriteState
    {
        get { return baseWriter.WriteState; }
    }

    public override void WriteString(string text)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteString(text);
    }

    public override void WriteSurrogateCharEntity(char lowChar, char highChar)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteSurrogateCharEntity(lowChar, highChar);
    }

    public override void WriteWhitespace(string ws)
    {
        if (IsSuspended)
            return;
        baseWriter.WriteWhitespace(ws);
    }
}

公共类元素SkippingXMLTextWriter:XmlWriterProxy
{
只读堆栈=新堆栈（）；
只读Func过滤器；
只读Func名称编辑器；
只读布尔过滤器儿童；
公共元素跳过XmlTextWriter（XmlWriter编写器、Func筛选器、布尔筛选器子项）
：此（writer、filter、null、filterChildren）
{
}
公共元素跳过XmlTextWriter（XmlWriter编写器、Func筛选器、Func名称编辑器、布尔筛选器子项）
：base（writer）
{
this.filter=filter？？委托{return true；}；
this.nameEditor=nameEditor？？委托（字符串localName，字符串ns，int-depth）{return localName；}；
this.filterChildren=filterChildren；
}
受保护的覆盖布尔值已解除
{
得到
{
if（过滤器儿童）
{
如果（！stack.All（b=>b））
返回true；
}
其他的
{
如果（stack.Count>0&&！stack.Peek（））
返回true；
}
返回base.issupended；
}
}
public override void writeStarteElement（字符串前缀、字符串localName、字符串ns）
{
var write=filter（localName、ns、stack.Count）；
var newLocalName=nameditor（localName，ns，stack.Count）；
如果（写入）
base.writeStarteElement（前缀，newLocalName，ns）；
栈。推（写）；
}
公共覆盖无效WriteEndElement（）
{
if（stack.Pop（））
base.WriteEndElement（）；
}
}
公共类XmlWriterProxy:XmlWriter
{
只读XmlWriter baseWriter；
公共XmlWriterProxy（XmlWriter baseWriter）
{
if（baseWriter==null）
抛出新ArgumentNullException（）；
this.baseWriter=baseWriter；
}
受保护的虚拟布尔IsSuspended{get{return false；}}
公共覆盖无效关闭（）
{
baseWriter.Close（）；
}
公共覆盖无效刷新（）
{
baseWriter.Flush（）；
}
公共重写字符串LookupPrefix（字符串ns）
{
返回baseWriter.LookupPrefix（ns）；
}
公共重写void WriteBase64（字节[]缓冲区，整数索引，整数计数）
{
如果（已发布）
返回；
baseWriter.WriteBase64（缓冲区、索引、计数）；
}
公共覆盖无效WriteCData（字符串文本）
{
如果（已发布）
返回；
baseWriter.WriteCData（文本）；
}
公共重写无效写入权限（char ch）
{
如果（已发布）
返回；
baseWriter.WriteCharEntity（ch）；
}
公共重写无效写卡（字符[]缓冲区、整数索引、整数计数）
{
如果（已发布）
返回；
baseWriter.WriteChars（缓冲区、索引、计数）；
}
公共覆盖无效WriteComment（字符串文本）
{
如果（已发布）
返回；
baseWriter.WriteComment（文本）；
}
public override void WriteDocType（字符串名称、字符串pubid、字符串sysid、字符串子集）
{
如果（已发布）
返回；
WriteDocType（名称、publid、sysid、子集）；
}
公共覆盖无效WriteEndAttribute（）
{
如果（已发布）
返回；
baseWriter.WriteEndAttribute（）；
}
公共覆盖无效WriteEndDocument（）
{
如果（已发布）
返回；
baseWriter.WriteEndDocument（）；
}
公共覆盖无效WriteEndElement（）
{
如果（已发布）
返回；
baseWriter.WriteEndElement（）；
}
公共重写无效WriteEntityRef（字符串名称）
{
如果（已发布）
返回；
baseWriter.WriteEntityRef（名称）；
}
public override void writeFileLendElement（）
{
如果（已发布）
返回；
baseWriter.WriteFileLendElement（）；
}
public override void WriteProcessingInstruction（字符串名称、字符串文本）
{
如果（已发布）
返回；
baseWriter.WriteProcessingInstruction（名称、文本）；
}
公共重写无效WriteRaw（字符串数据）
{
如果（已发布）
返回；
baseWriter.WriteRaw（数据）；
}
公共重写void WriteRaw（字符[]缓冲区、整数索引、整数计数）
{
如果（已发布）
返回；
baseWriter.WriteRaw（缓冲区、索引、计数）；
}
public override void WriteStartAttribute（字符串前缀、字符串localName、字符串ns）
{
如果（已发布）
返回；
baseWriter.WriteStartAttribute（前缀、localName、ns）；
}
公共覆盖无效WriteStartDocument（bool独立）
{
baseWriter.WriteStartDocument（独立）；
}
公共覆盖无效WriteStartDocument（）
{
baseWriter.WriteStartDocument（）；
}
public override void writeStarteElement（字符串前缀、字符串localName、字符串ns）
{
如果（已发布）
返回；
WriteStarteElement（前缀、localName、ns）；
}
公共优先权书面财产书面财产
{
获取{return baseWriter.WriteState；}
}
公共覆盖无效写入字符串（字符串文本）
{
如果（已发布）
返回；
baseWriter.WriteString（文本）；