JSON.Net在使用DeserializeObject之前过滤转义字符串，最佳实践

Question

我正在使用JSON.Net和JsonConvert.DeserializeObject函数将json加载到对象中。 json通常会使用转义字符串，这会导致DeserializeObject失败。 一些逃脱是：

\\'\\ u0027允许在字符文字中输入'，例如'\\'

\\“ \\ u0022允许在字符串文字中输入“”，例如“这是双引号（\\”）字符”

\\ \\ u005c允许在字符或字符串文字中输入\\字符，例如'\\'或“这是反斜杠（\\）字符”

\\ 0 \\ u0000允许输入代码为0的字符

\\ a \\ u0007警报（通常是硬件蜂鸣声）

\\ b \\ u0008退格键

\\ f \\ u000c换页（下一页）

\\ n \\ u000a换行（下一行）

\\ r \\ u000d回车（移动到行的开头）

\\ t \\ u0009（水平）标签

\\ v \\ u000b垂直标签

在http://www.codeproject.com/Articles/371232/Escaping-in-Csharp-characters-strings-string-forma中有一篇文章和代码，可能不需要诸如/ r / n之类的转义代码，因为C＃将了解他们。

在json文件中转义这些转义码是否有最佳实践？ 我想创建一个完整的类来处理数据，然后再将其传递给DeserializeObject。

任何人有任何想法吗？ 对于了解json.net和regex的人来说很简单。

Answer 1

如果我理解正确，则想将json转义序列转换回C＃转义序列。

如果是这样，您应该能够简单地搜索json转义并将其替换为实际的C＃转义：

var test = value.Replace(@"\u0085","\u0085");

我想从理论上讲，您可以将Json.Net的实用函数ToEscapedJavaScriptString()从json转义转换为C＃转义。

以下代码是我使用在codeplex上找到的Json.Net字符串序列化的稍作修改的版本。 我将其合并为一个辅助类。 这是他们将字符串从C＃转换为json的方式，因此也许会有所帮助。

// Copyright (c) 2007 James Newton-King    
namespace Demo
    {
        using System.Globalization;
        using System.IO;
        using System.Text;

        public class JsonHelper
        {
            public static string ToJson(string value, char delimiter = '"', bool appendDelimiters = true)
            {
                if (string.IsNullOrEmpty(value))
                    return value;

                StringBuilder sb = new StringBuilder(value.Length);
                using (StringWriter sw = new StringWriter(sb, CultureInfo.InvariantCulture))
                {
                    WriteEscapedString(sw, value, delimiter, appendDelimiters);
                    return sw.ToString();
                }
            }

            private static void WriteEscapedString(TextWriter writer, string s, char delimiter, bool appendDelimiters)
            {
                // leading delimiter
                if (appendDelimiters)
                    writer.Write(delimiter);

                if (s != null)
                {
                    char[] chars = null;
                    int lastWritePosition = 0;

                    for (int i = 0; i < s.Length; i++)
                    {
                        var c = s[i];

                        // don't escape standard text/numbers except '\' and the text delimiter
                        if (c >= ' ' && c < 128 && c != '\\' && c != delimiter)
                            continue;

                        string escapedValue;

                        switch (c)
                        {
                            case '\t': escapedValue = @"\t"; break;
                            case '\n': escapedValue = @"\n"; break;
                            case '\r': escapedValue = @"\r"; break;
                            case '\f': escapedValue = @"\f"; break;
                            case '\b': escapedValue = @"\b"; break;
                            case '\\': escapedValue = @"\\"; break;
                            case '\u0085': escapedValue = @"\u0085"; break; // Next Line
                            case '\u2028': escapedValue = @"\u2028"; break; // Line Separator
                            case '\u2029': escapedValue = @"\u2029"; break; // Paragraph Separator
                            case '\'': escapedValue = @"\'"; break;
                            case '"': escapedValue = "\\\""; break;
                            default: escapedValue = (c <= '\u001f') ? ToUnicode(c) : null; break;
                        }

                        if (escapedValue == null)
                            continue;

                        if (i > lastWritePosition)
                        {
                            if (chars == null)
                                chars = s.ToCharArray();

                            // write unchanged chars before writing escaped text
                            writer.Write(chars, lastWritePosition, i - lastWritePosition);
                        }

                        lastWritePosition = i + 1;
                        writer.Write(escapedValue);
                    }

                    if (lastWritePosition == 0)
                        // no escaped text, write entire string
                        writer.Write(s);
                    else
                    {
                        if (chars == null)
                            chars = s.ToCharArray();

                        // write remaining text
                        writer.Write(chars, lastWritePosition, s.Length - lastWritePosition);
                    }
                }

                // trailing delimiter
                if (appendDelimiters)
                    writer.Write(delimiter);
            }

            private static string ToUnicode(char c)
            {
                char h1 = ToHex((c >> 12) & '\x000f');
                char h2 = ToHex((c >> 8) & '\x000f');
                char h3 = ToHex((c >> 4) & '\x000f');
                char h4 = ToHex(c & '\x000f');

                return new string(new[] { '\\', 'u', h1, h2, h3, h4 });
            }

            private static char ToHex(int n)
            {
                if (n <= 9)
                    return (char)(n + 48);
                return 
                    (char)((n - 10) + 97);
            }

        }
    }