Quelle est la bonne façon de coder CR-LF sauts de ligne dans le texte/xml valeurs?

Par opposition à l'application/xml fichiers qui pourraient faire quelque chose, ou normalizedString valeurs qui convertir tous les espaces séquences à un seul caractère espace, je pose la question ici plus spécifiquement dans le contexte de fichiers texte/xml avec les valeurs de chaîne. Par souci de simplicité, disons que je suis le seul à l'aide de caractères ASCII d'un fichier encodé en UTF8.

Donné les deux suivants de la ligne de chaîne de texte que je souhaite représenter en XML:

Hello
World!

Qui est la suivante octets en mémoire:

0000: 48 65 6c 6c 6f 0d 0a 57 6f 72 6c 64 21 Hello..World!

Selon la RFC 2046, tout texte/* type MIME DOIT (devrait) représentent un saut de ligne à l'aide de Retour Chariot suivi par un caractère de Saut de ligne séquence. Dans cette lumière, le fragment XML suivant devrait être à droite:

<tag>Hello
World!</tag>

ou

0000: 3c 74 61 67 3c 48 65 6c 6c 6f 0d 0a 57 6f 72 6c <tag>Hello..Worl
0010: 64 21 3c 2f 74 61 67 3c                         d!</tag>

Mais je vais régulièrement voir les fichiers comme suit:

<tag><![CDATA[Hello
World!]]></tag>

Ou, encore plus étrange:

<tag>Hello&xD;
World!</tag>

Où l' &0xD; séquence est suivie par un seul caractère de Saut de ligne:

0000: 3c 74 61 67 3c 48 65 6c 6c 6f 26 78 44 3b 0a 57 <tag>Hello&xD;.W
0010: 6f 72 6c 64 21 3c 2f 74 61 67 3c                orld!</tag>

Ce qui me manque ici? Quelle est la bonne façon de représenter plusieurs lignes de texte dans une chaîne de caractères XML valeur, de sorte qu'il peut sortir de l'autre bout sans encombre?

OriginalL'auteur AlwaysLearning | 2013-02-22

  1. 2

    CR (&x0D;), LF (&) x0A;), CRLF, ou de quelques autres combinaisons sont toutes valides. Comme indiqué dans le spec, tous ces éléments sont convertis en une seule &x0A; le caractère.

    Selon les mêmes spécifications, CR (#d) est valide d'un Char à l'intérieur CDATA blocs et ne devrait donc pas être transformé. Je voudrais définir obtenir un LF de retour de CR LF entrée en tant que victimes de sévices sexuels. Est-il un moyen de coder correctement les XML pour obtenir la CR LF arrière à l'extrémité de réception, ou XML est juste cassé et ne méritent pas l'text/xml type MIME?
    Lors de la lecture de la spécification, - je l'interpréter comme ceci: si l'une des premières suivantes code point séquences se trouve dans l'entrée, le remplacer par 0xd 0xa: 0xd 0x85, 0x85, 0x2028, 0xd «anything other than 0xa or 0x85». Depuis ce remplacement se passe “avant l'analyse” (voir référence), tout caractère littéral de l'entité (c'est à dire, <tag>&#xd</tag>) doit être préservé. Donc, pour cet exemple, l'analyse de contenu doit être la séquence d'octets 0xd au lieu de 0xa. Je peux lire les spec correctement? Votre réponse semble suggérer que ce remplacement pourrait arriver après l'analyse au lieu de l'avant...

    OriginalL'auteur Eric Galluzzo

  2. 2

    Après l'écriture de tests NUnit en Mono et JUnit tests en Java, la réponse semble être d'utiliser soit <balise>Bonjour&#13;\nWorld!</balise> ou <balise>Bonjour&#xd;\nWorld!</balise> comme ci-dessous...

    Foo.cs:

    using System.IO;
using System.Text;
using System.Xml.Serialization;

namespace XmlStringTests
{
    public class Foo
    {
        public string greeting;

        public static Foo DeserializeFromXmlString (string xml)
        {
            Foo result;
            using (MemoryStream memoryStream = new MemoryStream()) {
                byte[] buffer = Encoding.UTF8.GetBytes (xml);
                memoryStream.Write (buffer, 0, buffer.Length);
                memoryStream.Seek (0, SeekOrigin.Begin);
                XmlSerializer xs = new XmlSerializer (typeof(Foo));
                result = (Foo)xs.Deserialize (memoryStream);
            }
            return result;
        }
    }
}

    XmlStringTests.cs:

    using NUnit.Framework;

namespace XmlStringTests
{
    [TestFixture]
    public class XmlStringTests
    {
        const string expected = "Hello\u000d\u000aWorld!";

        [Test(Description="Fails")]
        public void Cdata ()
        {
            const string test = "<Foo><greeting><![CDATA[Hello\u000d\u000aWorld!]]></greeting></Foo>";
            Foo bar = Foo.DeserializeFromXmlString (test);
            Assert.AreEqual (expected, bar.greeting);
        }

        [Test(Description="Fails")]
        public void CdataWithHash13 ()
        {
            const string test = "<Foo><greeting><![CDATA[Hello&#13;\u000aWorld!]]></greeting></Foo>";
            Foo bar = Foo.DeserializeFromXmlString (test);
            Assert.AreEqual (expected, bar.greeting);
        }

        [Test(Description="Fails")]
        public void CdataWithHashxD ()
        {
            const string test = "<Foo><greeting><![CDATA[Hello&#xd;\u000aWorld!]]></greeting></Foo>";
            Foo bar = Foo.DeserializeFromXmlString (test);
            Assert.AreEqual (expected, bar.greeting);
        }

        [Test(Description="Fails")]
        public void Simple ()
        {
            const string test = "<Foo><greeting>Hello\u000d\u000aWorld!</greeting></Foo>";
            Foo bar = Foo.DeserializeFromXmlString (test);
            Assert.AreEqual (expected, bar.greeting);
        }

        [Test(Description="Passes")]
        public void SimpleWithHash13 ()
        {
            const string test = "<Foo><greeting>Hello&#13;\u000aWorld!</greeting></Foo>";
            Foo bar = Foo.DeserializeFromXmlString (test);
            Assert.AreEqual (expected, bar.greeting);
        }

        [Test(Description="Passes")]
        public void SimpleWithHashxD ()
        {
            const string test = "<Foo><greeting>Hello&#xd;\u000aWorld!</greeting></Foo>";
            Foo bar = Foo.DeserializeFromXmlString (test);
            Assert.AreEqual (expected, bar.greeting);
        }
    }
}

    Foo.java:

    import java.io.StringReader;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlType;

@XmlRootElement(name = "Foo")
@XmlType(propOrder = { "greeting" })
public class Foo {
    public String greeting;

    public static Foo DeserializeFromXmlString(String xml) {
        try {
            JAXBContext context = JAXBContext.newInstance(Foo.class);
            Unmarshaller unmarshaller = context.createUnmarshaller();
            Foo foo = (Foo) unmarshaller.unmarshal(new StringReader(xml));
            return foo;
        } catch (JAXBException e) {
            e.printStackTrace();
            return null;
        }
    }
}

    XmlStringTests.java:

    import static org.junit.Assert.*;
import org.junit.Test;


public class XmlStringTests {
    String expected = "Hello\r\nWorld!";

    @Test //Fails
    public void testCdata ()
    {
        String test = "<Foo><greeting><![CDATA[Hello\r\nWorld!]]></greeting></Foo>";
        Foo bar = Foo.DeserializeFromXmlString (test);
        assertEquals (expected, bar.greeting);
    }

    @Test //Fails
    public void testCdataWithHash13 ()
    {
        String test = "<Foo><greeting><![CDATA[Hello&#13;\nWorld!]]></greeting></Foo>";
        Foo bar = Foo.DeserializeFromXmlString (test);
        assertEquals (expected, bar.greeting);
    }

    @Test //Fails
    public void testCdataWithHashxD ()
    {
        String test = "<Foo><greeting><![CDATA[Hello&#xd;\nWorld!]]></greeting></Foo>";
        Foo bar = Foo.DeserializeFromXmlString (test);
        assertEquals (expected, bar.greeting);
    }

    @Test //Fails
    public void testSimple ()
    {
        String test = "<Foo><greeting>Hello\r\nWorld!</greeting></Foo>";
        Foo bar = Foo.DeserializeFromXmlString (test);
        assertEquals (expected, bar.greeting);
    }

    @Test //Passes
    public void testSimpleWithHash13 ()
    {
        String test = "<Foo><greeting>Hello&#13;\nWorld!</greeting></Foo>";
        Foo bar = Foo.DeserializeFromXmlString (test);
        assertEquals (expected, bar.greeting);
    }

    @Test //Passes
    public void testSimpleWithHashxD ()
    {
        String test = "<Foo><greeting>Hello&#xd;\nWorld!</greeting></Foo>";
        Foo bar = Foo.DeserializeFromXmlString (test);
        assertEquals (expected, bar.greeting);
    }
}

    J'espère que cela permet de gagner du peuple un certain temps.

    OriginalL'auteur AlwaysLearning