XmlTextWriter incorrecte de l'écriture des caractères de contrôle

.NET XmlTextWriter crée des fichiers xml non valide.

En XML, certains caractères de contrôle sont autorisés, à l'instar de "horizontale onglet' (	), mais d'autres ne sont pas, comme "l'onglet vertical' (). (Voir spec.)

J'ai une chaîne de caractères qui contient un UTF-8 caractère de contrôle qui n'est pas autorisé dans XML.
Bien que XmlTextWriter échappe le caractère, le XML est bien sûr encore valides.

Comment puis-je m'assurer que XmlTextWriter produit jamais illégale d'un fichier XML?

Ou, s'il n'est pas possible de le faire avec XmlTextWriter, comment puis-je bande les caractères de contrôle spécifiques qui ne sont pas autorisés dans les données XML à partir d'une chaîne de caractères?

Exemple de code:

using (XmlTextWriter writer =
  new XmlTextWriter("test.xml", Encoding.UTF8))
{
  writer.WriteStartDocument();
  writer.WriteStartElement("Test");
  writer.WriteValue("hello \xb world");
  writer.WriteEndElement();
  writer.WriteEndDocument();
}

De sortie:

<?xml version="1.0" encoding="utf-8"?><Test>hello &#xB; world</Test>
Vous ne pouvez pas avoir une échappé à la verticale dans l'onglet XML? Pourriez-vous de référence de la norme?
C'est vrai, vous ne pouvez pas. XML est pour le texte, pas pour les caractères de contrôle ou de données binaires. w3.org/TR/REC-xml/#charsets

OriginalL'auteur Tom Lokhorst | 2011-11-24

  1. 12

    Cette documentation d'un comportement qui est caché dans le la documentation de la méthode WriteString mais il semble que cela s'applique à l'ensemble de la classe.

    Le comportement par défaut d'une XmlWriter créé à l'aide de Créer est à jeter
    ArgumentException lors de la tentative d'écrire des valeurs de caractère dans le
    gamme 0x-0x1F (à l'exclusion des caractères espace 0x9, 0xA, et 0xD).
    Ces caractères XML non valides peuvent être écrites par la création de la XmlWriter
    avec le CheckCharacters propriété est définie sur false. Cela entraîne
    dans les caractères remplacés par des entités de caractère numérique (&#0;
    par &#0x1F). En outre, un XmlTextWriter créés avec le nouveau
    l'opérateur va remplacer les caractères non valides avec des caractères numériques
    les entités par défaut.

    Il semble donc que vous finissez par écrire des caractères non valides parce que vous êtes à l'aide de la classe XmlTextWriter. Une meilleure solution pour vous serait d'utiliser la Classe XmlWriter à la place.

    C'est un peu bizarre, mais apparemment, même si le XmlTextWriter constructeur existe, vous n'êtes pas censé l'utiliser: msdn.microsoft.com/en-us/library/kkz7cs0d.aspx

    OriginalL'auteur jasso

  2. 3

    Viens de trouver cette question quand j'ai été aux prises avec le même problème et j'ai fini par le résoudre avec une regex:

    return Regex.Replace(s, @"[\u0000-\u0008\u000B\u000C\u000E-\u001F]", "");

    Espère que cela aide quelqu'un à une solution alternative.

    OriginalL'auteur rocco

  3. 1

    Construit en .NET évadés comme SecurityElement.Escape ne pas sortir correctement/bande.

    • Vous pouvez définir CheckCharacters à false sur l'écrivain et le lecteur, si votre application est la seule interaction avec le fichier. Le fichier XML résultant serait encore techniquement invalide.

    Voir:

    XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
xmlWriterSettings.Encoding = new UTF8Encoding(false);
xmlWriterSettings.CheckCharacters = false;
var sb = new StringBuilder();
var w = XmlWriter.Create(sb, xmlWriterSettings);
w.WriteStartDocument();
w.WriteStartElement("Test");
w.WriteString("hello \xb world");
w.WriteEndElement();
w.WriteEndDocument();
w.Close();
var xml = sb.ToString();
    • Si le réglage de CheckCharacters à true(qui est fait par défaut) est un peu trop strict car il sera tout simplement jeter une exception une approche alternative qui est plus indulgent pour des caractères XML non valides serait juste de bande:

    Googler un peu donné la liste blanche XmlTextEncoder cependant il va également supprimer DEL et d'autres dans la gamme U+007F–U+0084, U+0086–U+009F que, selon Caractères XML valides sur wikipédia ne sont valables que dans certains contextes et qui le RFC cite comme découragée, mais encore des caractères valides.

    public static class XmlTextExtentions
{
private static readonly Dictionary<char, string> textEntities = new Dictionary<char, string> {
{ '&', "&amp;"}, { '<', "&lt;" }, { '>', "&gt;" }, 
{ '"', "&quot;" }, { '\'', "&apos;" }
};
public static string ToValidXmlString(this string str)
{
var stripped = str
.Select((c,i) => new 
{ 
c1 = c, 
c2 = i + 1 < str.Length ? str[i+1]: default(char),
v = XmlConvert.IsXmlChar(c),
p = i + 1 < str.Length ? XmlConvert.IsXmlSurrogatePair(str[i + 1], c) : false,
pp = i > 0 ? XmlConvert.IsXmlSurrogatePair(c, str[i - 1]) : false
})
.Aggregate("", (s, c) => {                  
if (c.pp)
return s;
if (textEntities.ContainsKey(c.c1))
s += textEntities[c.c1];
else if (c.v)
s += c.c1.ToString();
else if (c.p)
s += c.c1.ToString() + c.c2.ToString();
return s;
});
return stripped;
}
}

    Ce passe tous les XmlTextEncoder tests sauf pour celui qui s'attend à ce que la bande DEL qui XmlConvert.IsXmlChar, Wikipedia, et la spécification des marques comme valide (bien que découragé).

    OriginalL'auteur Martijn Laarman