Je travaille avec du XML qui contient des chaînes comme:

<node>This is a string</node>

Certaines des chaînes que je passe aux nœuds auront des personnages comme &, #, $, etc .:

<node>This is a string & so is this</node>

Ce n'est pas valable en raison de &.

Je ne peux pas envelopper ces chaînes dans CDATA car elles doivent être telles qu'elles sont. J'ai essayé de chercher une liste de caractères qui ne peuvent pas être mis dans des nœuds XML sans être dans un CDATA.

Quelqu'un peut-il m'orienter vers l'un ou me fournir une liste de personnages illégaux?

Les seuls caractères illégaux sont &, <et >(ainsi que "ou 'dans les attributs).

Ils échappèrent à l' aide des entités XML , dans ce cas , vous voulez &pour &.

Vraiment, cependant, vous devriez utiliser un outil ou une bibliothèque qui écrit du XML pour vous et résume ce genre de chose pour vous afin que vous n'ayez pas à vous en soucier.

OK, séparons la question des personnages qui:

1. ne sont pas du tout valides dans aucun document XML.
2. doivent être échappés.

La réponse fournie par @dolmen dans " Quels sont les caractères non valides dans XML " est toujours valide mais doit être mise à jour avec la spécification XML 1.1.

1. Caractères non valides

Les caractères décrits ici sont tous les caractères autorisés à être insérés dans un document XML.

1.1. En XML 1.0

• Référence: voir la recommandation XML 1.0, §2.2 Caractères

La liste globale des caractères autorisés est:

[2] Char ::= #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] /* any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. */

Fondamentalement, les caractères de contrôle et les caractères hors des plages Unicode ne sont pas autorisés. Cela signifie également que l'appel par exemple de l'entité caractère est interdit.

1.2. Dans XML 1.1

• Référence: voir la recommandation XML 1.1, §2.2 Caractères , et 1.3 Justification et liste des modifications pour XML 1.1

La liste globale des caractères autorisés est:

[2] Char ::= [#x1-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF] /* any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. */

[2a] RestrictedChar ::= [#x1-#x8] | [#xB-#xC] | [#xE-#x1F] | [#x7F-#x84] | [#x86-#x9F]

Cette révision de la recommandation XML a étendu les caractères autorisés afin que les caractères de contrôle soient autorisés, et prend en compte une nouvelle révision de la norme Unicode, mais celles-ci ne sont toujours pas autorisées: NUL (x00) , xFFFE , xFFFF ...

Cependant, l'utilisation de caractères de contrôle et de caractères Unicode non définis est déconseillée.

On peut également remarquer que tous les analyseurs ne prennent pas toujours cela en compte et les documents XML avec des caractères de contrôle peuvent être rejetés.

2. Caractères à échapper (pour obtenir un document bien formé):

Le <doit être échappé avec une <entité, car il est supposé être le début d'une balise.

Le &doit être échappé avec une &entité, car il est supposé être le début d'une référence d'entité

Le >doit être échappé avec l' >entité. Ce n'est pas obligatoire - cela dépend du contexte - mais il est fortement conseillé d'y échapper.

Le 'doit être échappé avec une 'entité - obligatoire dans les attributs définis entre guillemets simples mais il est fortement conseillé de toujours l'échapper.

Le "devrait être échappé avec une "entité - obligatoire dans les attributs définis entre guillemets, mais il est fortement conseillé de toujours l'échapper.

La liste des caractères valides se trouve dans la spécification XML :

Char       ::=      #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]  /* any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. */

Il s'agit d'un code C # pour supprimer les caractères non valides XML d'une chaîne et renvoyer une nouvelle chaîne valide.

public static string CleanInvalidXmlChars(string text) 
{ 
    // From xml spec valid chars: 
    // #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]     
    // any Unicode character, excluding the surrogate blocks, FFFE, and FFFF. 
    string re = @"[^\x09\x0A\x0D\x20-\uD7FF\uE000-\uFFFD\u10000-\u10FFFF]"; 
    return Regex.Replace(text, re, ""); 
}

Les caractères pré-déclarés sont:

& < > " '

Voir « Quels sont les caractères spéciaux en XML? » Pour plus d'informations.

En plus de la réponse de potame, si vous voulez vous échapper en utilisant un bloc CDATA.

Si vous placez votre texte dans un bloc CDATA, vous n'avez pas besoin d'utiliser d'échappement . Dans ce cas, vous pouvez utiliser tous les caractères de la plage suivante :

Remarque: En plus de cela, vous n'êtes pas autorisé à utiliser la ]]>séquence de caractères. Parce qu'il correspondrait à la fin du bloc CDATA.

S'il y a encore des caractères invalides (par exemple des caractères de contrôle), alors il est probablement préférable d'utiliser une sorte de codage (par exemple base64).

Un autre moyen simple d'échapper aux caractères XML / XHTML potentiellement indésirables en C # est:

WebUtility.HtmlEncode(stringWithStrangeChars)

Une autre façon de supprimer les caractères XML incorrects en C # est d'utiliser XmlConvert.IsXmlChar(Disponible depuis .NET Framework 4.0)

public static string RemoveInvalidXmlChars(string content)
{
   return new string(content.Where(ch => System.Xml.XmlConvert.IsXmlChar(ch)).ToArray());
}

ou vous pouvez vérifier que tous les caractères sont valides pour XML:

public static bool CheckValidXmlChars(string content)
{
   return content.All(ch => System.Xml.XmlConvert.IsXmlChar(ch));
}

.Net Fiddle

Par exemple, le symbole de tabulation verticale ( \v) n'est pas valide pour XML, il est UTF-8 valide, mais pas XML 1.0 valide, et même de nombreuses bibliothèques (y compris libxml2) le manquent et produisent silencieusement du XML invalide.

En résumé, les caractères valides dans le texte sont:

• tabulation, saut de ligne et retour chariot.
• tous les caractères non contrôlés sont valides sauf & et <.
• >n'est pas valide s'il suit ]].

Les sections 2.2 et 2.4 de la spécification XML fournissent la réponse en détail:

Personnages

Les caractères légaux sont tabulation, retour chariot, saut de ligne et les caractères légaux d'Unicode et ISO / IEC 10646

Données de caractère

Le caractère esperluette (&) et le crochet angulaire gauche (<) ne doivent pas apparaître dans leur forme littérale, sauf lorsqu'ils sont utilisés comme délimiteurs de balisage, ou dans un commentaire, une instruction de traitement ou une section CDATA. S'ils sont nécessaires ailleurs, ils doivent être échappés à l'aide de références de caractères numériques ou des chaînes "&" et "<" respectivement. La parenthèse à angle droit (>) peut être représentée à l'aide de la chaîne ">" et doit, pour des raisons de compatibilité, être échappée à l'aide de ">" ou d'une référence de caractère lorsqu'elle apparaît dans la chaîne "]]>" dans le contenu, lorsque cela la chaîne ne marque pas la fin d'une section CDATA.

" XmlWriter et les caractères ASCII inférieurs " ont fonctionné pour moi

string code = Regex.Replace(item.Code, @"[\u0000-\u0008,\u000B,\u000C,\u000E-\u001F]", "");

ampersand (&) is escaped to &

double quotes (") are escaped to "

single quotes (') are escaped to ' 

less than (<) is escaped to &lt; 

greater than (>) is escaped to &gt;

En C #, utilisez System.Security.SecurityElement.Escapeou System.Net.WebUtility.HtmlEncodepour échapper à ces caractères illégaux.

string xml = "<node>it's my \"node\" & i like it 0x12 x09 x0A  0x09 0x0A <node>";
string encodedXml1 = System.Security.SecurityElement.Escape(xml);
string encodedXml2= System.Net.WebUtility.HtmlEncode(xml);


encodedXml1
"&lt;node&gt;it&apos;s my &quot;node&quot; &amp; i like it 0x12 x09 x0A  0x09 0x0A &lt;node&gt;"

encodedXml2
"&lt;node&gt;it&#39;s my &quot;node&quot; &amp; i like it 0x12 x09 x0A  0x09 0x0A &lt;node&gt;"

Pour les gens Java, Apache a une classe utilitaire ( StringEscapeUtils) qui a une méthode d'assistance escapeXmlqui peut être utilisée pour échapper des caractères dans une chaîne à l'aide d'entités XML.

Dans le processeur XML Woodstox, les caractères non valides sont classés par ce code:

if (c == 0) {
    throw new IOException("Invalid null character in text to output");
}
if (c < ' ' || (c >= 0x7F && c <= 0x9F)) {
    String msg = "Invalid white space character (0x" + Integer.toHexString(c) + ") in text to output";
    if (mXml11) {
        msg += " (can only be output using character entity)";
    }
    throw new IOException(msg);
}
if (c > 0x10FFFF) {
    throw new IOException("Illegal unicode character point (0x" + Integer.toHexString(c) + ") to output; max is 0x10FFFF as per RFC");
}
/*
 * Surrogate pair in non-quotable (not text or attribute value) content, and non-unicode encoding (ISO-8859-x,
 * Ascii)?
 */
if (c >= SURR1_FIRST && c <= SURR2_LAST) {
    throw new IOException("Illegal surrogate pair -- can only be output via character entities, which are not allowed in this content");
}
throw new IOException("Invalid XML character (0x"+Integer.toHexString(c)+") in text to output");

Source d' ici

Quelqu'un a essayé ça System.Security.SecurityElement.Escape(yourstring)? Cela remplacera les caractères XML non valides dans une chaîne par leur équivalent valide.

Pour XSL (les jours vraiment paresseux) j'utilise:

capture="&(?!amp;)" capturereplace="&"

pour traduire tous les signes & qui ne sont pas suivis på amp; aux bons.

Nous avons des cas où l'entrée est en CDATA mais le système qui utilise le XML n'en tient pas compte. C'est une solution bâclée, méfiez-vous ...