关于c＃：在构造使用该数据的XmlReader或XPathDocument之前，如何从基于XML的数据源中删除无效的十六进制字符？

How do you remove invalid hexadecimal characters from an XML-based data source prior to constructing an XmlReader or XPathDocument that uses the data?

在XmlReader中使用它之前，是否有任何简单/通用的方法来清理基于XML的数据源，以便我可以正常使用与XML上的十六进制字符限制不符的XML数据？

注意：

该解决方案需要处理XML
使用字符的数据源
UTF-8以外的其他编码，例如通过
在指定字符编码
XML文档声明。不
修改的字符编码
去除无效时的源
十六进制字符一直是
主要症结。
删除无效的十六进制字符仅应删除十六进制编码的值，因为您经常会在数据中发现恰好包含一个字符串(该字符串与十六进制字符匹配)的href值。

背景：

我需要使用符合特定格式(例如Atom或RSS提要)的基于XML的数据源，但希望能够使用已发布的数据源(根据XML规范包含无效的十六进制字符)。

在.NET中，如果您有一个表示XML数据源的Stream，然后尝试使用XmlReader和/或XPathDocument对其进行解析，则会由于XML数据中包含无效的十六进制字符而引发异常。我当前解决此问题的尝试是将Stream解析为字符串，并使用正则表达式删除和/或替换无效的十六进制字符，但是我正在寻找一种性能更高的解决方案。

这可能并不完美(由于人们错过了此免责声明，因此添加了重点)，但是在此情况下，我的工作如下。您可以调整以与流一起使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

/// <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 == '
' || ch == '
')
//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();

}

我喜欢尤金的白名单概念。我需要做与原始海报类似的操作，但是我需要支持所有Unicode字符，而不仅仅是0x00FD。 XML规范是：

字符=＃x9 | #xA | #xD | [＃x20-＃xD7FF] | [＃xE000-＃xFFFD] | [＃x10000-＃x10FFFF]

在.NET中，Unicode字符的内部表示形式只有16位，因此我们不能明确地"允许" 0x10000-0x10FFFF。 XML规范明确禁止出现从0xD800开始的替代代码点。但是，如果我们允许在白名单中使用这些替代代码点，则只要对字符串中的utf-16字符替代对产生了正确的utf-8编码，最后对字符串进行utf-8编码就可能产生有效的XML。 .NET字符串。不过，我还没有对此进行探讨，因此我选择了比较安全的选择，并且不允许将替代产品列入我的白名单。

不过，尤金解决方案中的注释具有误导性，问题在于我们排除的字符在XML中无效……它们是完全有效的Unicode代码点。我们不会删除"非UTF-8字符"。我们将删除格式不正确的XML文档中可能不会出现的utf-8字符。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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中提供。这是小样本：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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;
}
}

此答案的解决方案的DRY实现(使用其他构造函数-随时在您的应用程序中使用所需的构造函数)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

现代化dnewcombe的答案，您可以采用更简单的方法

1
2
3
4
5
6
7
8
9
10
11

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

1
2
3
4
5
6
7
8
9

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中dnewcome的答案。它只是包装了一个真正的流读取器，并在读取字符时替换了它们。

我只采用了几种方法来节省时间。我将其与XDocument.Load和文件流结合使用，并且仅调用了Read(char []缓冲区，int索引，int计数)方法，因此它的工作原理是这样的。您可能需要实现其他方法才能使此方法适用于您的应用程序。我使用这种方法是因为它似乎比其他答案更有效。我也只实现了一个构造函数，显然，您可以实现所需的任何StreamReader构造函数，因为它只是一个传递。

我选择替换字符而不是删除字符，因为它极大地简化了解决方案。这样，文本的长度保持不变，因此无需跟踪单独的索引。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

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();
}
}

基于正则表达式的方法

1
2
3
4

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,"");

}

有关更多详细信息，请参见我的博客文章

上面的Neolisk修改后的答案或原始答案。

更改：传递了 0个字符，删除已完成，而不是替换。也使用XmlConvert.IsXmlChar(char)方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

/// <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之前删除无效字符。

使用此代码从XML字符串中删除无效的XML字符。例如。＆x1A;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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;
}

Strip Illegal XML Characters based on W3C standard

我创建了@Neolisk答案的稍微更新的版本，该版本支持*Async函数并使用.Net 4.0 XmlConvert.IsXmlChar函数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

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);
}
}

使用此功能删除无效的xml字符。

1
2
3
4
5

public static string CleanInvalidXmlChars(string text)
{
string re = @"[^\x09\x0A\x0D\x20-\xD7FF\xE000-\xFFFD\x10000-x10FFFF]";
return Regex.Replace(text, re,"");
}

您可以通过以下方式传递非UTF字符：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

string sFinalString ="";
string hex ="";
foreach (char ch in UTFCHAR)
{
int tmp = ch;
if ((ch < 0x00FD && ch > 0x001F) || ch == '\t' || ch == '
' || ch == '
')
{
sFinalString += ch;
}
else
{
sFinalString +="&#" + tmp+";";
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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 == '
' || ch == '
') ) {
byteArr[i]=' ';
}
}
return new String( byteArr );
}

试试这个PHP！