String escape em XML

Existe alguma função C # que poderia ser usada para escapar e cancelar o escape de uma string, que poderia ser usada para preencher o conteúdo de um elemento XML?

Estou usando o VSTS 2008 + C # + .Net 3.0.

EDIT 1: Estou concatenando um arquivo XML simples e curto e não uso a serialização, então preciso escapar explicitamente o caractere XML à mão, por exemplo, preciso colocar a<bem <foo></foo>, portanto, preciso escapar da string a<be colocá-la no 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 (string s)

EDIT: Você diz "Estou concatenando um arquivo XML simples e curto e não uso a serialização, então preciso escapar explicitamente do caractere XML manualmente".

Eu recomendo fortemente que você não faça isso manualmente. Use as APIs XML para fazer tudo por você - leia os arquivos originais, mescle os dois em um único documento da maneira que for necessário (provavelmente você deseja usar XmlDocument.ImportNode) e, em seguida, escreva novamente. Você não quer escrever seus próprios analisadores / formatadores XML. A serialização é um tanto irrelevante aqui.

Se você puder nos dar um exemplo breve, mas completo, de exatamente o que está tentando fazer, provavelmente podemos ajudá-lo a evitar a preocupação de escapar em primeiro lugar.

Resposta original

Não está totalmente claro o que você quer dizer, mas normalmente APIs XML fazem isso para você. Você define o texto em um nó e ele automaticamente escapará de tudo o que for necessário. Por exemplo:

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

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

Resultado de ambos os exemplos:

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

Isso presumindo que você deseja escape de XML, é claro. Se não estiver, poste mais detalhes.

Agradecimentos a @sehe pelo escape de uma linha:

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

Acrescento a ele o un-escape de uma linha:

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

George, é simples. Sempre use as APIs XML para lidar com XML. Eles fazem todas as fugas e unescaping para você.

Nunca crie XML anexando strings.

E se você quiser, como eu quando encontrei esta pergunta, escapar dos nomes de nós XML, como por exemplo ao ler de uma serialização XML, use a maneira mais fácil:

XmlConvert.EncodeName(string nameToEscape)

Ele também escapará de espaços e quaisquer caracteres inválidos para elementos XML.

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

AVISO: Necromante

Ainda assim, a resposta de Darin Dimitrov + System.Security.SecurityElement.Escape (string s) não está completa.

No XML 1.1, a maneira mais simples e segura é apenas codificar TUDO.
Gostar 	de \ t.
Não tem suporte em XML 1.0.
Para XML 1.0, uma solução possível é codificar em base 64 o texto que contém o (s) caractere (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);
}

Outra abordagem baseada na resposta de John Skeet que não retorna as tags :

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

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

Isso retorna apenas o valor passado, em formato codificado em XML:

Brackets & stuff <> and "quotes"

As funções a seguir farão o trabalho. Não testei com o XmlDocument, mas acho que é muito mais 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 uma biblioteca de terceiros ( 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();
}

Exemplo:

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

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