Escape de cadena en XML

¿Existe alguna función de C # que pueda usarse para escapar y anular el escape de una cadena, que podría usarse para completar el contenido de un elemento XML?

Estoy usando VSTS 2008 + C # + .Net 3.0.

EDITAR 1: Estoy concatenando un archivo XML simple y corto y no uso la serialización, por lo que necesito escapar explícitamente el carácter XML a mano, por ejemplo, necesito a<bingresar <foo></foo>, así que necesito una cadena de escape a<by ponerla en el elemento 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 (cadenas)

EDITAR: Dice "Estoy concatenando un archivo XML simple y corto y no uso la serialización, por lo que necesito escapar explícitamente del carácter XML a mano".

Le recomiendo encarecidamente que no lo haga a mano. Use las API XML para hacerlo todo por usted: lea los archivos originales, combine los dos en un solo documento como lo necesite (probablemente quiera usarlo XmlDocument.ImportNode) y luego escríbalo nuevamente. No desea escribir sus propios analizadores / formateadores XML. La serialización es algo irrelevante aquí.

Si nos puede dar un ejemplo breve pero completo de exactamente lo que está tratando de hacer, probablemente podamos ayudarlo a evitar tener que preocuparse por escapar en primer lugar.

Respuesta original

No está del todo claro lo que quiere decir, pero normalmente las API XML lo hacen por usted. Establece el texto en un nodo y automáticamente escapará de todo lo que necesite. Por ejemplo:

Ejemplo de LINQ to XML:

using System;
using System.Xml.Linq;

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

        Console.WriteLine(element);
    }
}

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

Salida de ambos ejemplos:

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

Eso es asumiendo que desea que XML escape, por supuesto. Si no es así, publique más detalles.

Gracias a @sehe por el escape de una línea:

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

Le agrego el un-escape de una línea:

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

George, es simple. Utilice siempre las API XML para manejar XML. Ellos hacen todo el escape y desaparición por ti.

Nunca cree XML agregando cadenas.

Y si desea, como yo cuando encontré esta pregunta, escapar de los nombres de nodo XML, como por ejemplo al leer de una serialización XML, use la forma más fácil:

XmlConvert.EncodeName(string nameToEscape)

También escapará espacios y cualquier carácter no válido para elementos XML.

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

ADVERTENCIA: Nigromante

Aún así, la respuesta de Darin Dimitrov + System.Security.SecurityElement.Escape (string s) no está completa.

En XML 1.1, la forma más sencilla y segura es simplemente codificar TODO.
Como 	para \ t.
No se admite en absoluto en XML 1.0.
Para XML 1.0, una posible solución es codificar en base 64 el texto que contiene los caracteres.

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

Otra toma basada en la respuesta de John Skeet que no devuelve las etiquetas :

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

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

Esto devuelve solo el valor pasado, en formato codificado XML:

Brackets & stuff <> and "quotes"

Las siguientes funciones harán el trabajo. No probé contra XmlDocument, pero supongo que esto es mucho más rápido.

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

Usando una biblioteca de terceros ( Newtonsoft.Json ) como alternativa:

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

Ejemplo:

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

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