Как удалить недопустимые шестнадцатеричные символы из источника данных на основе XML перед созданием XmlReader или XPathDocument, использующего данные?
https://stackoverflow.com/questions/20762
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianВопрос
Существует ли какой-нибудь простой/общий способ очистки источника данных на основе XML перед его использованием в XmlReader, чтобы я мог корректно использовать данные XML, не соответствующие ограничениям на шестнадцатеричные символы, наложенным на XML?
Примечание:
- Решение должно обрабатывать источники данных XML, которые используют кодировки символов, отличные от UTF-8, например,указав кодирование символов на объявлении документа XML.Не погорание персонажа, кодирующего источника, в то время как снятие недействительных шестнадцатеричных персонажей было главной точкой привязки.
- Удаление недопустимых шестнадцатеричных символов должно удалять только значения в шестнадцатеричной кодировке, поскольку вы часто можете найти значения href в данных, которые содержат строку, которая будет соответствовать строке шестнадцатеричного символа.
Фон:
Мне нужно использовать источник данных на основе XML, который соответствует определенному формату (например, Atom или RSS-каналы), но я хочу иметь возможность использовать опубликованные источники данных, которые содержат недопустимые шестнадцатеричные символы в соответствии со спецификацией XML.
В .NET, если у вас есть поток, представляющий источник данных XML, а затем вы пытаетесь проанализировать его с помощью XmlReader и/или XPathDocument, возникает исключение из-за включения недопустимых шестнадцатеричных символов в данные XML.Моя текущая попытка решить эту проблему — проанализировать поток как строку и использовать регулярное выражение для удаления и/или замены недопустимых шестнадцатеричных символов, но я ищу более производительное решение.
Решение
Это может быть не идеально (выделение добавлено, поскольку люди пропустили это заявление об отказе от ответственности), но то, что я сделал в этом случае, описано ниже.Вы можете настроить использование с потоком.
/// <summary>
/// Removes control characters and other non-UTF-8 characters
/// </summary>
/// <param name="inString">The string to process</param>
/// <returns>A string with no control characters or entities above 0x00FD</returns>
public static string RemoveTroublesomeCharacters(string inString)
{
if (inString == null) return null;
StringBuilder newString = new StringBuilder();
char ch;
for (int i = 0; i < inString.Length; i++)
{
ch = inString[i];
// remove any characters outside the valid UTF-8 range as well as all control characters
// except tabs and new lines
//if ((ch < 0x00FD && ch > 0x001F) || ch == '\t' || ch == '\n' || ch == '\r')
//if using .NET version prior to 4, use above logic
if (XmlConvert.IsXmlChar(ch)) //this method is new in .NET 4
{
newString.Append(ch);
}
}
return newString.ToString();
}
Другие советы
Мне нравится концепция белого списка Юджина.Мне нужно было сделать то же самое, что и исходный плакат, но мне нужно было поддерживать все символы Юникода, а не только до 0x00FD.Спецификация XML:
Char = #x9 | #xa | #xd | [#x20-#xd7ff] | [#xe000-#xfffd] | [#x10000-#x10ffff
В .NET внутреннее представление символов Юникода составляет всего 16 бит, поэтому мы не можем явно «разрешить» 0x10000-0x10FFFF.Спецификация XML явно запрещает точки суррогатного кода, начинающиеся с 0xD800, не появляются.Однако возможно, что если бы мы разрешили эти суррогатные кодовые точки в нашем белом списке, кодировка utf-8 нашей строки могла бы в конечном итоге создать действительный XML, если правильная кодировка utf-8 была создана из суррогатных пар символов utf-16 в .NET-строка.Однако я не исследовал этот вопрос, поэтому выбрал более безопасный вариант и не включил суррогатных матерей в свой белый список.
Однако комментарии в решении Юджина вводят в заблуждение, проблема в том, что символы, которые мы исключаем, недопустимы в XML ...они являются совершенно допустимыми кодовыми точками Unicode.Мы не удаляем символы, отличные от utf-8.Мы удаляем символы utf-8, которые могут не отображаться в правильно сформированных XML-документах.
public static string XmlCharacterWhitelist( string in_string ) {
if( in_string == null ) return null;
StringBuilder sbOutput = new StringBuilder();
char ch;
for( int i = 0; i < in_string.Length; i++ ) {
ch = in_string[i];
if( ( ch >= 0x0020 && ch <= 0xD7FF ) ||
( ch >= 0xE000 && ch <= 0xFFFD ) ||
ch == 0x0009 ||
ch == 0x000A ||
ch == 0x000D ) {
sbOutput.Append( ch );
}
}
return sbOutput.ToString();
}
В качестве способа удаления недопустимых символов XML я предлагаю вам использовать XmlConvert.IsXmlChar метод.Он был добавлен начиная с .NET Framework 4 и также представлен в Silverlight.Вот небольшой образец:
void Main() {
string content = "\v\f\0";
Console.WriteLine(IsValidXmlString(content)); // False
content = RemoveInvalidXmlChars(content);
Console.WriteLine(IsValidXmlString(content)); // True
}
static string RemoveInvalidXmlChars(string text) {
char[] validXmlChars = text.Where(ch => XmlConvert.IsXmlChar(ch)).ToArray();
return new string(validXmlChars);
}
static bool IsValidXmlString(string text) {
try {
XmlConvert.VerifyXmlChars(text);
return true;
} catch {
return false;
}
}
СУХАЯ реализация этот ответрешение (с использованием другого конструктора - не стесняйтесь использовать тот, который вам нужен в вашем приложении):
public class InvalidXmlCharacterReplacingStreamReader : StreamReader
{
private readonly char _replacementCharacter;
public InvalidXmlCharacterReplacingStreamReader(string fileName, char replacementCharacter) : base(fileName)
{
this._replacementCharacter = replacementCharacter;
}
public override int Peek()
{
int ch = base.Peek();
if (ch != -1 && IsInvalidChar(ch))
{
return this._replacementCharacter;
}
return ch;
}
public override int Read()
{
int ch = base.Read();
if (ch != -1 && IsInvalidChar(ch))
{
return this._replacementCharacter;
}
return ch;
}
public override int Read(char[] buffer, int index, int count)
{
int readCount = base.Read(buffer, index, count);
for (int i = index; i < readCount + index; i++)
{
char ch = buffer[i];
if (IsInvalidChar(ch))
{
buffer[i] = this._replacementCharacter;
}
}
return readCount;
}
private static bool IsInvalidChar(int ch)
{
return (ch < 0x0020 || ch > 0xD7FF) &&
(ch < 0xE000 || ch > 0xFFFD) &&
ch != 0x0009 &&
ch != 0x000A &&
ch != 0x000D;
}
}
Модернизация Дьюкомбс ответ, вы могли бы использовать немного более простой подход
public static string RemoveInvalidXmlChars(string input)
{
var isValid = new Predicate<char>(value =>
(value >= 0x0020 && value <= 0xD7FF) ||
(value >= 0xE000 && value <= 0xFFFD) ||
value == 0x0009 ||
value == 0x000A ||
value == 0x000D);
return new string(Array.FindAll(input.ToCharArray(), isValid));
}
или с помощью Linq
public static string RemoveInvalidXmlChars(string input)
{
return new string(input.Where(value =>
(value >= 0x0020 && value <= 0xD7FF) ||
(value >= 0xE000 && value <= 0xFFFD) ||
value == 0x0009 ||
value == 0x000A ||
value == 0x000D).ToArray());
}
Мне было бы интересно узнать, как сравнивается производительность этих методов и как они все сравниваются с подходом, основанным на черном списке, с использованием Buffer.BlockCopy.
Вот пришелответ в пользовательском StreamReader.Он просто оборачивает настоящую программу чтения потока и заменяет символы по мере их чтения.
Я реализовал лишь несколько методов, чтобы сэкономить время.Я использовал это вместе с XDocument.Load и файловым потоком, и вызывался только метод Read(char[] buffer, int index, int count), поэтому он работал следующим образом.Возможно, вам придется реализовать дополнительные методы, чтобы это работало в вашем приложении.Я использовал этот подход, потому что он кажется более эффективным, чем другие ответы.Я также реализовал только один из конструкторов, вы, очевидно, можете реализовать любой из конструкторов StreamReader, который вам нужен, поскольку это всего лишь проход.
Я решил заменить символы, а не удалять их, потому что это значительно упрощает решение.Таким образом, длина текста остается неизменной, поэтому нет необходимости отслеживать отдельный индекс.
public class InvalidXmlCharacterReplacingStreamReader : TextReader
{
private StreamReader implementingStreamReader;
private char replacementCharacter;
public InvalidXmlCharacterReplacingStreamReader(Stream stream, char replacementCharacter)
{
implementingStreamReader = new StreamReader(stream);
this.replacementCharacter = replacementCharacter;
}
public override void Close()
{
implementingStreamReader.Close();
}
public override ObjRef CreateObjRef(Type requestedType)
{
return implementingStreamReader.CreateObjRef(requestedType);
}
public void Dispose()
{
implementingStreamReader.Dispose();
}
public override bool Equals(object obj)
{
return implementingStreamReader.Equals(obj);
}
public override int GetHashCode()
{
return implementingStreamReader.GetHashCode();
}
public override object InitializeLifetimeService()
{
return implementingStreamReader.InitializeLifetimeService();
}
public override int Peek()
{
int ch = implementingStreamReader.Peek();
if (ch != -1)
{
if (
(ch < 0x0020 || ch > 0xD7FF) &&
(ch < 0xE000 || ch > 0xFFFD) &&
ch != 0x0009 &&
ch != 0x000A &&
ch != 0x000D
)
{
return replacementCharacter;
}
}
return ch;
}
public override int Read()
{
int ch = implementingStreamReader.Read();
if (ch != -1)
{
if (
(ch < 0x0020 || ch > 0xD7FF) &&
(ch < 0xE000 || ch > 0xFFFD) &&
ch != 0x0009 &&
ch != 0x000A &&
ch != 0x000D
)
{
return replacementCharacter;
}
}
return ch;
}
public override int Read(char[] buffer, int index, int count)
{
int readCount = implementingStreamReader.Read(buffer, index, count);
for (int i = index; i < readCount+index; i++)
{
char ch = buffer[i];
if (
(ch < 0x0020 || ch > 0xD7FF) &&
(ch < 0xE000 || ch > 0xFFFD) &&
ch != 0x0009 &&
ch != 0x000A &&
ch != 0x000D
)
{
buffer[i] = replacementCharacter;
}
}
return readCount;
}
public override Task<int> ReadAsync(char[] buffer, int index, int count)
{
throw new NotImplementedException();
}
public override int ReadBlock(char[] buffer, int index, int count)
{
throw new NotImplementedException();
}
public override Task<int> ReadBlockAsync(char[] buffer, int index, int count)
{
throw new NotImplementedException();
}
public override string ReadLine()
{
throw new NotImplementedException();
}
public override Task<string> ReadLineAsync()
{
throw new NotImplementedException();
}
public override string ReadToEnd()
{
throw new NotImplementedException();
}
public override Task<string> ReadToEndAsync()
{
throw new NotImplementedException();
}
public override string ToString()
{
return implementingStreamReader.ToString();
}
}
Подход на основе регулярных выражений
public static string StripInvalidXmlCharacters(string str)
{
var invalidXmlCharactersRegex = new Regex("[^\u0009\u000a\u000d\u0020-\ud7ff\ue000-\ufffd]|([\ud800-\udbff](?![\udc00-\udfff]))|((?<![\ud800-\udbff])[\udc00-\udfff])");
return invalidXmlCharactersRegex.Replace(str, "");
}
Смотри мой Сообщение блога Больше подробностей
Вышеупомянутые решения, похоже, предназначены для удаления недопустимых символов перед преобразованием в XML.
Используйте этот код для удаления недопустимых символов XML из строки XML.например.&x1А;
public static string CleanInvalidXmlChars( string Xml, string XMLVersion )
{
string pattern = String.Empty;
switch( XMLVersion )
{
case "1.0":
pattern = @"&#x((10?|[2-F])FFF[EF]|FDD[0-9A-F]|7F|8[0-46-9A-F]9[0-9A-F]);";
break;
case "1.1":
pattern = @"&#x((10?|[2-F])FFF[EF]|FDD[0-9A-F]|[19][0-9A-F]|7F|8[0-46-9A-F]|0?[1-8BCEF]);";
break;
default:
throw new Exception( "Error: Invalid XML Version!" );
}
Regex regex = new Regex( pattern, RegexOptions.IgnoreCase );
if( regex.IsMatch( Xml ) )
Xml = regex.Replace( Xml, String.Empty );
return Xml;
}
http://balajiramesh.wordpress.com/2008/05/30/strip-illegal-xml-characters-based-on-w3c-standard/
Измененный ответ или оригинальный ответ от Неолиск выше.
Изменения:передан символ \0, выполняется удаление, а не замена.также использовал метод XmlConvert.IsXmlChar(char)
/// <summary>
/// Replaces invalid Xml characters from input file, NOTE: if replacement character is \0, then invalid Xml character is removed, instead of 1-for-1 replacement
/// </summary>
public class InvalidXmlCharacterReplacingStreamReader : StreamReader
{
private readonly char _replacementCharacter;
public InvalidXmlCharacterReplacingStreamReader(string fileName, char replacementCharacter)
: base(fileName)
{
_replacementCharacter = replacementCharacter;
}
public override int Peek()
{
int ch = base.Peek();
if (ch != -1 && IsInvalidChar(ch))
{
if ('\0' == _replacementCharacter)
return Peek(); // peek at the next one
return _replacementCharacter;
}
return ch;
}
public override int Read()
{
int ch = base.Read();
if (ch != -1 && IsInvalidChar(ch))
{
if ('\0' == _replacementCharacter)
return Read(); // read next one
return _replacementCharacter;
}
return ch;
}
public override int Read(char[] buffer, int index, int count)
{
int readCount= 0, ch;
for (int i = 0; i < count && (ch = Read()) != -1; i++)
{
readCount++;
buffer[index + i] = (char)ch;
}
return readCount;
}
private static bool IsInvalidChar(int ch)
{
return !XmlConvert.IsXmlChar((char)ch);
}
}
Используйте эту функцию для удаления недопустимых символов XML.
public static string CleanInvalidXmlChars(string text)
{
string re = @"[^\x09\x0A\x0D\x20-\xD7FF\xE000-\xFFFD\x10000-x10FFFF]";
return Regex.Replace(text, re, "");
}
я создал немного обновленная версия из Ответ @Neoisk, который поддерживает *Async функционирует и использует .Net 4.0 XmlConvert.IsXmlChar функция.
public class InvalidXmlCharacterReplacingStreamReader : StreamReader
{
private readonly char _replacementCharacter;
public InvalidXmlCharacterReplacingStreamReader(string fileName, char replacementCharacter) : base(fileName)
{
_replacementCharacter = replacementCharacter;
}
public InvalidXmlCharacterReplacingStreamReader(Stream stream, char replacementCharacter) : base(stream)
{
_replacementCharacter = replacementCharacter;
}
public override int Peek()
{
var ch = base.Peek();
if (ch != -1 && IsInvalidChar(ch))
{
return _replacementCharacter;
}
return ch;
}
public override int Read()
{
var ch = base.Read();
if (ch != -1 && IsInvalidChar(ch))
{
return _replacementCharacter;
}
return ch;
}
public override int Read(char[] buffer, int index, int count)
{
var readCount = base.Read(buffer, index, count);
ReplaceInBuffer(buffer, index, readCount);
return readCount;
}
public override async Task<int> ReadAsync(char[] buffer, int index, int count)
{
var readCount = await base.ReadAsync(buffer, index, count).ConfigureAwait(false);
ReplaceInBuffer(buffer, index, readCount);
return readCount;
}
private void ReplaceInBuffer(char[] buffer, int index, int readCount)
{
for (var i = index; i < readCount + index; i++)
{
var ch = buffer[i];
if (IsInvalidChar(ch))
{
buffer[i] = _replacementCharacter;
}
}
}
private static bool IsInvalidChar(int ch)
{
return IsInvalidChar((char)ch);
}
private static bool IsInvalidChar(char ch)
{
return !XmlConvert.IsXmlChar(ch);
}
}
private static String removeNonUtf8CompliantCharacters( final String inString ) {
if (null == inString ) return null;
byte[] byteArr = inString.getBytes();
for ( int i=0; i < byteArr.length; i++ ) {
byte ch= byteArr[i];
// remove any characters outside the valid UTF-8 range as well as all control characters
// except tabs and new lines
if ( !( (ch > 31 && ch < 253 ) || ch == '\t' || ch == '\n' || ch == '\r') ) {
byteArr[i]=' ';
}
}
return new String( byteArr );
}
Вы можете передавать символы, отличные от UTF, следующим образом:
string sFinalString = "";
string hex = "";
foreach (char ch in UTFCHAR)
{
int tmp = ch;
if ((ch < 0x00FD && ch > 0x001F) || ch == '\t' || ch == '\n' || ch == '\r')
{
sFinalString += ch;
}
else
{
sFinalString += "&#" + tmp+";";
}
}
Попробуйте это для PHP!
$goodUTF8 = iconv("utf-8", "utf-8//IGNORE", $badUTF8);
