String-Escape in XML

Gibt es eine C # -Funktion, mit der eine Zeichenfolge maskiert und nicht maskiert werden kann, um den Inhalt eines XML-Elements auszufüllen?

Ich verwende VSTS 2008 + C # + .Net 3.0.

EDIT 1: Ich bin einfach und kurz XML - Datei verketten und ich verwende die Serialisierung nicht, so dass ich explizit muß XML - Zeichen mit der Hand entkommen, zum Beispiel, ich brauche zu setzen a<bin <foo></foo>, so dass ich String entkommen muss a<bund es in dem Elemente foo setzen.

public static string XmlEscape(string unescaped)
{
    XmlDocument doc = new XmlDocument();
    XmlNode node = doc.CreateElement("root");
    node.InnerText = unescaped;
    return node.InnerXml;
}

public static string XmlUnescape(string escaped)
{
    XmlDocument doc = new XmlDocument();
    XmlNode node = doc.CreateElement("root");
    node.InnerXml = escaped;
    return node.InnerText;
}

SecurityElement.Escape (Zeichenfolge s)

BEARBEITEN: Sie sagen "Ich verkette einfache und kurze XML-Dateien und verwende keine Serialisierung, daher muss ich XML-Zeichen explizit von Hand maskieren".

Ich würde Ihnen dringend raten, dies nicht von Hand zu tun. Verwenden Sie die XML-APIs, um alles für Sie zu erledigen - lesen Sie die Originaldateien ein und führen Sie die beiden Dateien zu einem einzigen Dokument zusammen, wie Sie möchten (wahrscheinlich möchten Sie es verwenden)XmlDocument.ImportNode ), und schreiben Sie es dann erneut aus. Sie möchten keine eigenen XML-Parser / Formatierer schreiben. Serialisierung ist hier etwas irrelevant.

Wenn Sie uns ein kurzes, aber vollständiges Beispiel dafür geben können, was Sie genau tun möchten, können wir Ihnen wahrscheinlich dabei helfen, sich keine Sorgen über die Flucht machen zu müssen.

Ursprüngliche Antwort

Es ist nicht ganz klar, was Sie meinen, aber normalerweise erledigen XML-APIs dies für Sie. Sie legen den Text in einem Knoten fest und er entgeht automatisch allem, was er benötigt. Beispielsweise:

Beispiel für LINQ to XML:

using System;
using System.Xml.Linq;

class Test
{
    static void Main()
    {
        XElement element = new XElement("tag",
                                        "Brackets & stuff <>");

        Console.WriteLine(element);
    }
}

DOM-Beispiel:

using System;
using System.Xml;

class Test
{
    static void Main()
    {
        XmlDocument doc = new XmlDocument();
        XmlElement element = doc.CreateElement("tag");
        element.InnerText = "Brackets & stuff <>";
        Console.WriteLine(element.OuterXml);
    }
}

Ausgabe aus beiden Beispielen:

<tag>Brackets &amp; stuff &lt;&gt;</tag>

Dies setzt natürlich voraus, dass XML entkommen soll. Wenn nicht, posten Sie bitte weitere Details.

Vielen Dank an @sehe für die einzeilige Flucht:

var escaped = new System.Xml.Linq.XText(unescaped).ToString();

Ich füge noch die einzeilige Flucht hinzu:

var unescapedAgain = System.Xml.XmlReader.Create(new StringReader("<r>" + escaped + "</r>")).ReadElementString();

George, es ist einfach. Verwenden Sie immer die XML-APIs, um mit XML umzugehen. Sie erledigen alles für Sie, um zu entkommen und zu entkommen.

Erstellen Sie niemals XML, indem Sie Zeichenfolgen anhängen.

Und wenn Sie, wie ich, als ich diese Frage gefunden habe, XML-Knotennamen umgehen möchten, wie zum Beispiel beim Lesen aus einer XML-Serialisierung, verwenden Sie den einfachsten Weg:

XmlConvert.EncodeName(string nameToEscape)

Leerzeichen und ungültige Zeichen für XML-Elemente werden ebenfalls ausgeblendet.

http://msdn.microsoft.com/en-us/library/system.security.securityelement.escape%28VS.80%29.aspx

WARNUNG: Nekromantie

Die Antwort von Darin Dimitrov + System.Security.SecurityElement.Escape (Zeichenfolge) ist immer noch nicht vollständig.

In XML 1.1 besteht der einfachste und sicherste Weg darin, ALLES zu codieren.
Wie 	für \ t.
Es wird in XML 1.0 überhaupt nicht unterstützt.
Für XML 1.0 besteht eine mögliche Problemumgehung darin, den Text, der die Zeichen enthält, mit Base-64 zu codieren.

//string EncodedXml = SpecialXmlEscape("привет мир");
//Console.WriteLine(EncodedXml);
//string DecodedXml = XmlUnescape(EncodedXml);
//Console.WriteLine(DecodedXml);
public static string SpecialXmlEscape(string input)
{
    //string content = System.Xml.XmlConvert.EncodeName("\t");
    //string content = System.Security.SecurityElement.Escape("\t");
    //string strDelimiter = System.Web.HttpUtility.HtmlEncode("\t"); // XmlEscape("\t"); //XmlDecode("	");
    //strDelimiter = XmlUnescape("&#59;");
    //Console.WriteLine(strDelimiter);
    //Console.WriteLine(string.Format("&#{0};", (int)';'));
    //Console.WriteLine(System.Text.Encoding.ASCII.HeaderName);
    //Console.WriteLine(System.Text.Encoding.UTF8.HeaderName);


    string strXmlText = "";

    if (string.IsNullOrEmpty(input))
        return input;


    System.Text.StringBuilder sb = new StringBuilder();

    for (int i = 0; i < input.Length; ++i)
    {
        sb.AppendFormat("&#{0};", (int)input[i]);
    }

    strXmlText = sb.ToString();
    sb.Clear();
    sb = null;

    return strXmlText;
} // End Function SpecialXmlEscape

XML 1.0:

public static string Base64Encode(string plainText)
{
    var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plainText);
    return System.Convert.ToBase64String(plainTextBytes);
}

public static string Base64Decode(string base64EncodedData)
{
    var base64EncodedBytes = System.Convert.FromBase64String(base64EncodedData);
    return System.Text.Encoding.UTF8.GetString(base64EncodedBytes);
}

Eine weitere Einstellung, die auf John Skeets Antwort basiert und die Tags nicht zurückgibt :

void Main()
{
    XmlString("Brackets & stuff <> and \"quotes\"").Dump();
}

public string XmlString(string text)
{
    return new XElement("t", text).LastNode.ToString();
} 

Dies gibt nur den übergebenen Wert im XML-codierten Format zurück:

Brackets & stuff <> and "quotes"

Die folgenden Funktionen erledigen die Arbeit. Ich habe nicht gegen XmlDocument getestet, aber ich denke, das ist viel schneller.

public static string XmlEncode(string value)
{
    System.Xml.XmlWriterSettings settings = new System.Xml.XmlWriterSettings 
    {
        ConformanceLevel = System.Xml.ConformanceLevel.Fragment
    };

    StringBuilder builder = new StringBuilder();

    using (var writer = System.Xml.XmlWriter.Create(builder, settings))
    {
        writer.WriteString(value);
    }

    return builder.ToString();
}

public static string XmlDecode(string xmlEncodedValue)
{
    System.Xml.XmlReaderSettings settings = new System.Xml.XmlReaderSettings
    {
        ConformanceLevel = System.Xml.ConformanceLevel.Fragment
    };

    using (var stringReader = new System.IO.StringReader(xmlEncodedValue))
    {
        using (var xmlReader = System.Xml.XmlReader.Create(stringReader, settings))
        {
            xmlReader.Read();
            return xmlReader.Value;
        }
    }
}

Verwenden einer Bibliothek eines Drittanbieters ( Newtonsoft.Json ) als Alternative:

public static string XmlEncode(string unescaped)
{
    if (unescaped == null) return null;
    return JsonConvert.SerializeObject(unescaped); ;
}

public static string XmlDecode(string escaped)
{
    if (escaped == null) return null;
    return JsonConvert.DeserializeObject(escaped, typeof(string)).ToString();
}

Beispiel:

a<b <==> "a<b"

<foo></foo> <==> "foo></foo>"