Chaîne d'échappement dans XML

Existe-t-il une fonction C # qui pourrait être utilisée pour échapper et déséchapper une chaîne, qui pourrait être utilisée pour remplir le contenu d'un élément XML?

J'utilise VSTS 2008 + C # + .Net 3.0.

EDIT 1: Je suis concaténer simple et fichier XML court et je ne l' utilise sérialisation, donc je dois échapper explicitement le caractère XML à la main, par exemple, je dois mettre a<ben <foo></foo>, donc j'ai besoin échapper corde a<bet de le mettre dans l' élément foo.

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 (chaîne s)

EDIT: Vous dites "Je concatène un fichier XML simple et court et je n'utilise pas de sérialisation, donc j'ai besoin d'échapper explicitement au caractère XML à la main".

Je vous déconseille fortement de le faire à la main. Utilisez les API XML pour tout faire pour vous - lisez les fichiers d'origine, fusionnez les deux en un seul document comme vous en avez besoin (vous voulez probablement l'utiliser XmlDocument.ImportNode), puis réécrivez-le. Vous ne voulez pas écrire vos propres analyseurs / formateurs XML. La sérialisation est quelque peu hors de propos ici.

Si vous pouvez nous donner un exemple bref mais complet de ce que vous essayez de faire exactement, nous pouvons probablement vous aider à éviter d'avoir à vous soucier de vous échapper en premier lieu.

Réponse originale

Ce que vous voulez dire n'est pas tout à fait clair, mais normalement les API XML le font pour vous. Vous définissez le texte dans un nœud, et il échappera automatiquement à tout ce dont il a besoin. Par exemple:

Exemple LINQ to XML:

using System;
using System.Xml.Linq;

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

        Console.WriteLine(element);
    }
}

Exemple DOM:

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);
    }
}

Résultat des deux exemples:

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

Cela suppose que vous vouliez que XML s'échappe, bien sûr. Si ce n'est pas le cas, veuillez publier plus de détails.

Merci à @sehe pour l'évasion en une ligne:

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

J'ajoute à cela le un-escape d'une ligne:

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

George, c'est simple. Utilisez toujours les API XML pour gérer XML. Ils font tout ce qui vous échappe et ne vous échappe pas.

Ne créez jamais de XML en ajoutant des chaînes.

Et si vous voulez, comme moi quand j'ai trouvé cette question, échapper aux noms de nœuds XML, comme par exemple lors de la lecture à partir d'une sérialisation XML, utilisez le moyen le plus simple:

XmlConvert.EncodeName(string nameToEscape)

Il échappera également les espaces et tous les caractères non valides pour les éléments XML.

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

AVERTISSEMENT: Nécromance

La réponse de Darin Dimitrov + System.Security.SecurityElement.Escape (string s) n'est toujours pas complète.

Dans XML 1.1, le moyen le plus simple et le plus sûr est de simplement encoder TOUT.
Comme 	pour \ t.
Il n'est pas du tout pris en charge dans XML 1.0.
Pour XML 1.0, une solution de contournement possible consiste à encoder en base 64 le texte contenant le (s) caractère (s).

//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);
}

Une autre prise basée sur la réponse de John Skeet qui ne renvoie pas les balises :

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

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

Cela renvoie uniquement la valeur transmise, au format encodé XML:

Brackets & stuff <> and "quotes"

Les fonctions suivantes feront le travail. Je n'ai pas testé contre XmlDocument, mais je suppose que c'est beaucoup plus rapide.

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;
        }
    }
}

Utilisation d'une bibliothèque tierce ( Newtonsoft.Json ) comme 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();
}

Exemple:

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

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