修复无效JSON的最有效方法

您需要通过JavaScript运行它。在.net中启动一个JavaScript解析器。将字符串作为JavaScript的输入，并使用JavaScript的原生JSON.stringify进行转换：

obj = {
    "user":'180111',
    "title":'I''m sure "E pluribus unum" means ''Out of Many, One.'' 'n'nhttp://en.wikipedia.org/wiki/E_pluribus_unum.'n'n',
    "date":'2007/01/10 19:48:38',
    "id":"3322121",
    "previd":"112211",
    "body":"''You'' can '"read'" more here [url=http:'/'/en.wikipedia.org'/?search=E_pluribus_unum]E pluribus unum['/url]'s. Cheers ''*/ :'/",
    "from":"112221",
    "username":"mikethunder",
    "creationdate":"2007'/01'/10 14:04:49"
}
console.log(JSON.stringify(obj));
document.write(JSON.stringify(obj));

请记住，您得到的字符串（或者更确切地说是对象）不是有效的JSON，无法使用JSON库进行解析。它需要首先转换为有效的JSON。但是它是有效的JavaScript。

要完成此答案：您可以在.Net中使用JavaScriptSerializer。对于此解决方案，您需要以下程序集：

• System.Net

• System.Web.Script.Serialization

  var webClient = new WebClient();
  string readHtml = webClient.DownloadString("uri to your source (extraterrestrial)");
  var a = new JavaScriptSerializer();
  Dictionary<string, object> results = a.Deserialize<Dictionary<string, object>>(readHtml);
  

这个怎么样：

 string AlienJSON = "your alien JSON";
 JavaScriptSerializer js = new JavaScriptSerializer();
 string ProperJSON = js.Serialize(js.DeserializeObject(AlienJSON));

或者只是在反序列化后使用对象，而不是将其转换回字符串并将其传递给JSON解析器以获得额外的头痛

正如Mouser还提到的，您需要使用System.Web.Script.Serialization，这可以通过在项目中包含System.Web.extensions.dll来实现，为此，您需要将项目属性中的Target framework更改为.NET Framework 4。

编辑

使用反序列化对象的诀窍是使用dynamic

JavaScriptSerializer js = new JavaScriptSerializer();
dynamic obj = js.DeserializeObject(AlienJSON);

对于问题中的JSON，只需使用

string body = obj["body"];

或者如果您的JSON是数组

if (obj is Array) {
    foreach(dynamic o in obj){
        string body = obj[0]["body"];
        // ... do something with it
    }
}

这里有一个我制作的函数，它将修复损坏的json:

function fixJSON(json){
    function bulkRegex(str, callback){
        if(callback && typeof callback === 'function'){
            return callback(str);
        }else if(callback && Array.isArray(callback)){
            for(let i = 0; i < callback.length; i++){
                if(callback[i] && typeof callback[i] === 'function'){
                    str = callback[i](str);
                }else{break;}
            }
            return str;
        }
        return str;
    }
    if(json && json !== ''){
        if(typeof json !== 'string'){
            try{
                json = JSON.stringify(json);
            }catch(e){return false;}
        }
        if(typeof json === 'string'){
            json = bulkRegex(json, false, [
                str => str.replace(/['n't]/gm, ''),
                str => str.replace(/,'}/gm, '}'),
                str => str.replace(/,']/gm, ']'),
                str => {
                    str = str.split(/(?=[,'}']])/g);
                    str = str.map(s => {
                        if(s.includes(':') && s){
                            let strP = s.split(/:(.+)/, 2);
                            strP[0] = strP[0].trim();
                            if(strP[0]){
                                let firstP = strP[0].split(/([,'{'[])/g);
                                firstP[firstP.length-1] = bulkRegex(firstP[firstP.length-1], false, p => p.replace(/[^A-Za-z0-9'-_]/, ''));
                                strP[0] = firstP.join('');
                            }
                            let part = strP[1].trim();
                            if((part.startsWith('"') && part.endsWith('"')) || (part.startsWith('''') && part.endsWith('''')) || (part.startsWith('`') && part.endsWith('`'))){
                                part = part.substr(1, part.length - 2);
                            }
                            part = bulkRegex(part, false, [
                                p => p.replace(/(["])/gm, '''$1'),
                                p => p.replace(/'''/gm, ''''),
                                p => p.replace(/''`/gm, '`'),
                            ]);
                            strP[1] = ('"'+part+'"').trim();
                            s = strP.join(':');
                        }
                        return s;
                    });
                    return str.join('');
                },
                str => str.replace(/(['"])?([a-zA-Z0-9'-_]+)(['"])?:/g, '"$2":'),
                str => {
                    str = str.split(/(?=[,'}']])/g);
                    str = str.map(s => {
                        if(s.includes(':') && s){
                            let strP = s.split(/:(.+)/, 2);
                            strP[0] = strP[0].trim();
                            if(strP[1].includes('"') && strP[1].includes(':')){
                                let part = strP[1].trim();
                                if(part.startsWith('"') && part.endsWith('"')){
                                    part = part.substr(1, part.length - 2);
                                    part = bulkRegex(part, false, p => p.replace(/(?<!'')"/gm, ''));
                                }
                                strP[1] = ('"'+part+'"').trim();
                            }
                            s = strP.join(':');
                        }
                        return s;
                    });
                    return str.join('');
                },
            ]);
            try{
                json = JSON.parse(json);
            }catch(e){return false;}
        }
        return json;
    }
    return false;
}