Existe uma maneira de escapar de um token final CDATA em xml?

Eu queria saber se existe alguma maneira de escapar de um token final CDATA ( ]]>) dentro de uma seção CDATA em um documento xml. Ou, de maneira mais geral, se houver alguma sequência de escape para uso em um CDATA (mas, se existir, acho que provavelmente só faria sentido escapar dos tokens iniciais ou finais).

Basicamente, você pode ter um token de início ou fim incorporado em um CDATA e dizer ao analisador para não interpretá-lo, mas tratá-lo como apenas mais uma sequência de caracteres.

Provavelmente, você deve refatorar sua estrutura xml ou seu código se tentar fazer isso, mas mesmo que eu trabalhe com xml diariamente nos últimos 3 anos ou mais e nunca tenha tido esse problema, Fiquei me perguntando se era possível. Apenas por curiosidade.

Editar:

Além de usar a codificação html ...

Claramente, esta questão é puramente acadêmica. Felizmente, tem uma resposta muito definida.

Você não pode escapar de uma sequência final CDATA. A regra de produção 20 da especificação XML é bastante clara:

[20]    CData      ::=      (Char* - (Char* ']]>' Char*))

EDIT: Esta regra do produto significa literalmente "Uma seção CData pode conter o que você deseja, mas a sequência ']]>'. Sem exceção.".

EDIT2: A mesma seção também lê:

Dentro de uma seção CDATA, somente a seqüência CDEnd é reconhecida como marcação, para que colchetes ee comercial do ângulo esquerdo possam ocorrer em sua forma literal; eles não precisam (e não podem) ser escapados usando " <" e " &". As seções CDATA não podem ser aninhadas.

Em outras palavras, não é possível usar referência de entidade, marcação ou qualquer outra forma de sintaxe interpretada. O único texto analisado dentro de uma seção CDATA é ]]>e termina a seção.

Portanto, não é possível escapar ]]>dentro de uma seção CDATA.

EDIT3: A mesma seção também lê:

2.7 Seções CDATA

[Definição: as seções CDATA podem ocorrer em qualquer lugar em que dados de caracteres possam ocorrer; eles são usados ​​para escapar de blocos de texto contendo caracteres que, de outra forma, seriam reconhecidos como marcação. As seções CDATA começam com a sequência "<! [CDATA [" e terminam com a sequência "]]>":]

Pode haver uma seção CDATA em qualquer lugar em que dados de caracteres possam ocorrer, incluindo várias seções CDATA adjacentes no lugar de uma única seção CDATA. Isso permite que seja possível dividir o ]]>token e colocar as duas partes em seções CDATA adjacentes.

ex:

<![CDATA[Certain tokens like ]]> can be difficult and <invalid>]]> 

deve ser escrito como

<![CDATA[Certain tokens like ]]]]><![CDATA[> can be difficult and <valid>]]> 

Você precisa dividir seus dados em pedaços para ocultar o arquivo ]]>.

Aqui está a coisa toda:

<![CDATA[]]]]><![CDATA[>]]>

O primeiro <![CDATA[]]]]>tem o ]]. O segundo <![CDATA[>]]>tem o >.

Você não escapa do, ]]>mas escapa do >depois ]]inserindo ]]><![CDATA[antes do >, pense nisto como uma \string C / Java / PHP / Perl, mas necessário apenas antes >e depois de a ]].

BTW,

A resposta de S.Lott é a mesma, mas com palavras diferentes.

A resposta de S. Lott está certa: você não codifica a tag final, divide-a em várias seções CDATA.

Como enfrentar esse problema no mundo real: usando um editor XML para criar um documento XML que será alimentado em um sistema de gerenciamento de conteúdo, tente escrever um artigo sobre as seções CDATA. Seu truque comum de incorporar exemplos de código em uma seção CDATA falhará aqui. Você pode imaginar como eu aprendi isso.

Mas na maioria das circunstâncias, você não encontrará isso, e aqui está o porquê: se você deseja armazenar (digamos) o texto de um documento XML como o conteúdo de um elemento XML, provavelmente usará um método DOM, por exemplo:

XmlElement elm = doc.CreateElement("foo");
elm.InnerText = "<[CDATA[[Is this a problem?]]>";

E o DOM escapa razoavelmente do <e do>, o que significa que você não incorporou inadvertidamente uma seção CDATA ao seu documento.

Ah, e isso é interessante:

XmlDocument doc = new XmlDocument();

XmlElement elm = doc.CreateElement("doc");
doc.AppendChild(elm);

string data = "<![[CDATA[This is an embedded CDATA section]]>";
XmlCDataSection cdata = doc.CreateCDataSection(data);
elm.AppendChild(cdata);

Provavelmente é uma ideosincrasia do .NET DOM, mas isso não gera uma exceção. A exceção é lançada aqui:

Console.Write(doc.OuterXml);

Eu acho que o que está acontecendo nos bastidores é que o XmlDocument está usando um XmlWriter produz sua saída, e o XmlWriter verifica se há boa formação durante a gravação.

simplesmente substitua ]]>por]]]]><![CDATA[>

Aqui está outro caso em que ]]>precisa ser escapado. Suponha que precisamos salvar um documento HTML perfeitamente válido dentro de um bloco CDATA de um documento XML e que a origem HTML possua seu próprio bloco CDATA. Por exemplo:

<htmlSource><![CDATA[ 
    ... html ...
    <script type="text/javascript">
        /* <![CDATA[ */
        -- some working javascript --
        /* ]]> */
    </script>
    ... html ...
]]></htmlSource>

o sufixo CDATA comentado precisa ser alterado para:

        /* ]]]]><![CDATA[> *//

como um analisador XML não saberá como lidar com blocos de comentários javascript

Em PHP: '<![CDATA['.implode(explode(']]>', $string), ']]]]><![CDATA[>').']]>'

Uma maneira mais limpa em PHP:

   function safeCData($string)
   {
      return '<![CDATA[' . str_replace(']]>', ']]]]><![CDATA[>', $string) . ']]>';
   }

Não se esqueça de usar um str_replace multibyte-safe, se necessário (não latin1 $string):

   function mb_str_replace($search, $replace, $subject, &$count = 0)
   {
      if (!is_array($subject))
      {
         $searches = is_array($search) ? array_values($search) : array ($search);
         $replacements = is_array($replace) ? array_values($replace) : array ($replace);
         $replacements = array_pad($replacements, count($searches), '');
         foreach ($searches as $key => $search)
         {
            $parts = mb_split(preg_quote($search), $subject);
            $count += count($parts) - 1;
            $subject = implode($replacements[$key], $parts);
         }
      }
      else
      {
         foreach ($subject as $key => $value)
         {
            $subject[$key] = mb_str_replace($search, $replace, $value, $count);
         }
      }
      return $subject;
   }

Não acho que interromper o CDATA seja um bom caminho a percorrer. Aqui está a minha alternativa ...

Use ]para a sequência de escape seguida pelo valor hexadecimal do seu personagem. Como no &#xhhhh;=>]<unicode value>;

Dessa forma, se você tentar gravar ]]>sua codificação, o fn produzirá o ]005D;]005D;]003E;que está correto no CDATA.

É melhor do que escapar pelo nome da entidade, porque eles não são decodificados todas as vezes no seu aplicativo e você pode ter prioridades diferentes para escapar de entidades com e comercial e escapar de outros caracteres / seqüências. Como resultado, você tem mais controle sobre o conteúdo do CDATA.

Veja esta estrutura:

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

Para as tags CDATA internas, você deve fechar com em ]]]]><![CDATA[>vez de ]]>. Simples assim.