Traiter avec XML non valide caractères hexadécimaux

byte[] toEncodeAsBytes
            = System.Text.ASCIIEncoding.ASCII.GetBytes(toEncode);
      string returnValue
            = System.Convert.ToBase64String(toEncodeAsBytes);

est une façon de le faire

OriginalL'auteur parapura rajkumar

La solution suivante supprime tous les caractères XML non valides, mais je pense que performantly comme cela pourrait être fait, et, en particulier, il ne pas allouer une nouvelle StringBuilder ainsi que d'une nouvelle chaîne, pas moins qu'il est déjà déterminé que la chaîne de caractères non valides. Donc, le point chaud finit par être seulement un seul pour la boucle sur les personnages, avec le chèque finissant souvent pas plus de deux supérieure /inférieure numérique des comparaisons sur chaque char. Si aucun n'est trouvé, il renvoie simplement la chaîne d'origine. Ceci est particulièrement utile lorsque la grande majorité des chaînes sont juste très bien pour commencer, c'est agréable d'avoir ces dans et hors (avec pas de gaspillage d'allocations etc) aussi rapide que possible.

-- update --

Voir ci-dessous comment on peut également écrire directement un XElement qui a ces caractères non valides, même si elle utilise ce code --

Une partie de ce code a été influencé par M. Tom Bogle la solution ici. Voir aussi sur ce même thread les informations utiles dans le post de superlogical. L'ensemble de ces, toutefois, toujours instancier un nouvel objet StringBuilder et de la chaîne.

UTILISATION:

    string xmlStrBack = XML.ToValidXmlCharactersString("any string");

TEST:

    public static void TestXmlCleanser()
    {
        string badString = "My name is Inigo Montoya"; //you may not see it, but bad char is in 'MontXoya'
        string goodString = "My name is Inigo Montoya!";

        string back1 = XML.ToValidXmlCharactersString(badString); //fixes it
        string back2 = XML.ToValidXmlCharactersString(goodString); //returns same string

        XElement x1 = new XElement("test", back1);
        XElement x2 = new XElement("test", back2);
        XElement x3WithBadString = new XElement("test", badString);

        string xml1 = x1.ToString();
        string xml2 = x2.ToString().Print();

        string xmlShouldFail = x3WithBadString.ToString();
    }

//--- CODE --- (j'ai de ces méthodes dans la statique de la classe utilitaire appelé XML)

    ///<summary>
///Determines if any invalid XML 1.0 characters exist within the string,
///and if so it returns a new string with the invalid chars removed, else 
///the same string is returned (with no wasted StringBuilder allocated, etc).
///</summary>
///<param name="s">Xml string.</param>
///<param name="startIndex">The index to begin checking at.</param>
public static string ToValidXmlCharactersString(string s, int startIndex = 0)
{
int firstInvalidChar = IndexOfFirstInvalidXMLChar(s, startIndex);
if (firstInvalidChar < 0)
return s;
startIndex = firstInvalidChar;
int len = s.Length;
var sb = new StringBuilder(len);
if (startIndex > 0)
sb.Append(s, 0, startIndex);
for (int i = startIndex; i < len; i++)
if (IsLegalXmlChar(s[i]))
sb.Append(s[i]);
return sb.ToString();
}
///<summary>
///Gets the index of the first invalid XML 1.0 character in this string, else returns -1.
///</summary>
///<param name="s">Xml string.</param>
///<param name="startIndex">Start index.</param>
public static int IndexOfFirstInvalidXMLChar(string s, int startIndex = 0)
{
if (s != null && s.Length > 0 && startIndex < s.Length) {
if (startIndex < 0) startIndex = 0;
int len = s.Length;
for (int i = startIndex; i < len; i++)
if (!IsLegalXmlChar(s[i]))
return i;
}
return -1;
}
///<summary>
///Indicates whether a given character is valid according to the XML 1.0 spec.
///This code represents an optimized version of Tom Bogle's on SO: 
///https://stackoverflow.com/a/13039301/264031.
///</summary>
public static bool IsLegalXmlChar(char c)
{
if (c > 31 && c <= 55295)
return true;
if (c < 32)
return c == 9 || c == 10 || c == 13;
return (c >= 57344 && c <= 65533) || c > 65535;
//final comparison is useful only for integral comparison, if char c -> int c, useful for utf-32 I suppose
//c <= 1114111 *///impossible to get a code point bigger than 1114111 because Char.ConvertToUtf32 would have thrown an exception
}

======== ======== ========

Écrire XElement.ToString directement

======== ======== ========

Tout d'abord, l'utilisation de cette méthode d'extension:

string result = xelem.ToStringIgnoreInvalidChars();

-- Fuller test --

    public static void TestXmlCleanser()
{
string badString = "My name is Inigo Montoya"; //you may not see it, but bad char is in 'MontXoya'
XElement x = new XElement("test", badString);
string xml1 = x.ToStringIgnoreInvalidChars();                               
//result: <test>My name is Inigo Montoya</test>
string xml2 = x.ToStringIgnoreInvalidChars(deleteInvalidChars: false);
//result: <test>My name is Inigo Mont&#x1E;oya</test>
}

--- code ---

    ///<summary>
///Writes this XML to string while allowing invalid XML chars to either be
///simply removed during the write process, or else encoded into entities, 
///instead of having an exception occur, as the standard XmlWriter.Create 
///XmlWriter does (which is the default writer used by XElement).
///</summary>
///<param name="xml">XElement.</param>
///<param name="deleteInvalidChars">True to have any invalid chars deleted, else they will be entity encoded.</param>
///<param name="indent">Indent setting.</param>
///<param name="indentChar">Indent char (leave null to use default)</param>
public static string ToStringIgnoreInvalidChars(this XElement xml, bool deleteInvalidChars = true, bool indent = true, char? indentChar = null)
{
if (xml == null) return null;
StringWriter swriter = new StringWriter();
using (XmlTextWriterIgnoreInvalidChars writer = new XmlTextWriterIgnoreInvalidChars(swriter, deleteInvalidChars)) {
//-- settings --
//unfortunately writer.Settings cannot be set, is null, so we can't specify: bool newLineOnAttributes, bool omitXmlDeclaration
writer.Formatting = indent ? Formatting.Indented : Formatting.None;
if (indentChar != null)
writer.IndentChar = (char)indentChar;
//-- write --
xml.WriteTo(writer); 
}
return swriter.ToString();
}

-- il utilise les éléments suivants XmlTextWritter --

public class XmlTextWriterIgnoreInvalidChars : XmlTextWriter
{
public bool DeleteInvalidChars { get; set; }
public XmlTextWriterIgnoreInvalidChars(TextWriter w, bool deleteInvalidChars = true) : base(w)
{
DeleteInvalidChars = deleteInvalidChars;
}
public override void WriteString(string text)
{
if (text != null && DeleteInvalidChars)
text = XML.ToValidXmlCharactersString(text);
base.WriteString(text);
}
}

OriginalL'auteur Nicholas Petersen

De travail pour moi:

XmlWriterSettings xmlWriterSettings = new XmlWriterSettings { Encoding = Encoding.UTF8, CheckCharacters = false };

OriginalL'auteur lucas teles

Une autre façon de supprimer XML incorrecte caractères en C# avec l'aide de XmlConvert.IsXmlChar Méthode (Disponible depuis .NET Framework 4.0)

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

.Net Violon https://dotnetfiddle.net/v1TNus

Par exemple, la verticale symbole de tabulation (\v) n'est pas valide pour le XML, c'est UTF-8 valide, mais pas valide XML 1.0, et même de nombreuses bibliothèques (y compris les libxml2) manquer et silencieux de sortie XML non valide.

OriginalL'auteur Alex Vazhev