the case of using Json in my working

客户端构造：

function UpdateOrAddMemberProperty(arrayObj, members)
{
    var flag = false;
    for(var i=0; i< arrayObj.length; i++)
    {
        if(arrayObj[i].DimID == members.DimID && arrayObj[i].MembersID == members.MembersID)
        {
        
                             
                for(var k=0; k< members.NewPropetiesValue.length; k++)  //each new prop
                {
                
                    var findProp = false;
                
                    //update prop
                    for(var j=0; j< arrayObj[i].NewPropetiesValue.length; j++)
                    {                
                            if(arrayObj[i].NewPropetiesValue[j].Name == members.NewPropetiesValue[k].Name)
                            {                                
                                arrayObj[i].NewPropetiesValue[j].Value = members.NewPropetiesValue[k].Value;
                                findProp = true;
                            }                            
                     }
                     
                     //add prop
                     if(findProp == false)
                     {
                        arrayObj[i].NewPropetiesValue.push(members.NewPropetiesValue[k]);
                     }
                     
                 }
                 
                 
                 flag = true;
             

        }
    }
    
    if(flag == false)
        arrayObj.push(members);
        
    return arrayObj;
}

function CacheChangedMembers()
{

        var strMembersChanged = parent.window.document.getElementById("membersChanged").value;
        //alert(strMembersChanged);
        var arrayMembersChanged = new Array();
        if(strMembersChanged.length > 0)
            arrayMembersChanged = strMembersChanged.parseAnalyzer();

        
        var propArray = new Array();
        
        var inputs = document.getElementsByTagName("input");
        for(var i=0;i<inputs.length;i++)
       {
            if(inputIsChanged(inputs[i]))
           {
                var prop  = new Object();
                prop.Name = inputs[i].propName;
                prop.Type = inputs[i].propType;
                prop.Value = inputs[i].value;
                propArray.push(prop);

           } 
       } 
       inputs = document.getElementsByTagName("select"); 
       for(var i=0;i<inputs.length;i++)
       {
            if(selectIsChanged(inputs[i]))
           {
                var prop  = new Object();
                prop.Name = inputs[i].propName;
                prop.Type = inputs[i].propType;
                prop.Value = inputs[i].value;
                propArray.push(prop);
           } 
       }
       
       //alert("prop:"+propArray.length);
       
       if(propArray.length > 0)
       {
            var members = new Object();
            members.DimID = document.getElementById("hiddenDimID").value;
            members.MembersID = document.getElementById("hiddenMemIds").value;
            members.NewPropetiesValue = propArray;  //related to another object
            
            arrayMembersChanged = UpdateOrAddMemberProperty(arrayMembersChanged,members);
            
            //arrayMembersChanged.push(members);
       }
       
       var result = arrayMembersChanged.toAnalyzerString();
       if(result == "[]")
            result = "";
            
       //alert(result);
       parent.window.document.getElementById("membersChanged").value = result;


       //alert(arrayMembersChanged.toAnalyzerString());
       //alert(document.getElementById("hiddenDimID").value);
       //alert(document.getElementById("hiddenMemIds").value);

}

客户端组件代码：

if (!Object.prototype.toAnalyzerString) {

    Array.prototype.toAnalyzerString = function (w) {
        var a = [],     // The array holding the partial texts.
            i,          // Loop counter.
            l = this.length,
            v;          // The value to be stringified.

// For each value in this array

        for (i = 0; i < l; i += 1) {
            v = this[i];
            switch (typeof v) {
            case 'object':

// Serialize a JavaScript object value. Treat objects thats lack the
// toAnalyzerString method as null. Due to a specification error in ECMAScript,
// typeof null is 'object', so watch out for that case.

                if (v && typeof v.toAnalyzerString === 'function') {
                    a.push(v.toAnalyzerString(w));
                } else {
                    a.push('null');
                }
                break;

            case 'string':
            case 'number':
            case 'boolean':
                a.push(v.toAnalyzerString());
                break;
            default:
                a.push('null');
            }
        }

// Join all of the member texts together and wrap them in brackets.

        return '[' + a.join(',') + ']';
    };


    Boolean.prototype.toAnalyzerString = function () {
        return String(this);
    };


    Date.prototype.toAnalyzerString = function () {

// Eventually, this method will be based on the date.toISOString method.

        function f(n) {

// Format integers to have at least two digits.

            return n < 10 ? '0' + n : n;
        }

        return '"' + this.getUTCFullYear()   + '-' +
                   f(this.getUTCMonth() + 1) + '-' +
                   f(this.getUTCDate())      + 'T' +
                   f(this.getUTCHours())     + ':' +
                   f(this.getUTCMinutes())   + ':' +
                   f(this.getUTCSeconds())   + 'Z"';
    };


    Number.prototype.toAnalyzerString = function () {

// Analyzer numbers must be finite. Encode non-finite numbers as null.

        return isFinite(this) ? String(this) : 'null';
    };


    Object.prototype.toAnalyzerString = function (w) {
        var a = [],     // The array holding the partial texts.
            k,          // The current key.
            i,          // The loop counter.
            v;          // The current value.

// If a whitelist (array of keys) is provided, use it assemble the components
// of the object.

        if (w) {
            for (i = 0; i < w.length; i += 1) {
                k = w[i];
                if (typeof k === 'string') {
                    v = this[k];
                    switch (typeof v) {
                    case 'object':

// Serialize a JavaScript object value. Ignore objects that lack the
// toAnalyzerString method. Due to a specification error in ECMAScript,
// typeof null is 'object', so watch out for that case.

                        if (v) {
                            if (typeof v.toAnalyzerString === 'function') {
                                a.push(k.toAnalyzerString() + ':' +
                                       v.toAnalyzerString(w));
                            }
                        } else {
                            a.push(k.toAnalyzerString() + ':null');
                        }
                        break;

                    case 'string':
                    case 'number':
                    case 'boolean':
                        a.push(k.toAnalyzerString() + ':' + v.toAnalyzerString());

// Values without a Analyzer representation are ignored.

                    }
                }
            }
        } else {

// Iterate through all of the keys in the object, ignoring the proto chain
// and keys that are not strings.

            for (k in this) {
                if (typeof k === 'string' &&
                        Object.prototype.hasOwnProperty.apply(this, [k])) {
                    v = this[k];
                    switch (typeof v) {
                    case 'object':

// Serialize a JavaScript object value. Ignore objects that lack the
// toAnalyzerString method. Due to a specification error in ECMAScript,
// typeof null is 'object', so watch out for that case.

                        if (v) {
                            if (typeof v.toAnalyzerString === 'function') {
                                a.push(k.toAnalyzerString() + ':' +
                                       v.toAnalyzerString());
                            }
                        } else {
                            a.push(k.toAnalyzerString() + ':null');
                        }
                        break;

                    case 'string':
                    case 'number':
                    case 'boolean':
                        a.push(k.toAnalyzerString() + ':' + v.toAnalyzerString());

// Values without a Analyzer representation are ignored.

                    }
                }
            }
        }

// Join all of the member texts together and wrap them in braces.

        return '{' + a.join(',') + '}';
    };


    (function (s) {

// Augment String.prototype. We do this in an immediate anonymous function to
// avoid defining global variables.

// m is a table of character substitutions.

        var m = {
            '\b': '\\b',
            '\t': '\\t',
            '\n': '\\n',
            '\f': '\\f',
            '\r': '\\r',
            '"' : '\\"',
            '\\': '\\\\'
        };


        s.parseAnalyzer = function (filter) {
            var j;

            function walk(k, v) {
                var i, n;
                if (v && typeof v === 'object') {
                    for (i in v) {
                        if (Object.prototype.hasOwnProperty.apply(v, [i])) {
                            n = walk(i, v[i]);
                            if (n !== undefined) {
                                v[i] = n;
                            } else {
                                delete v[i];
                            }
                        }
                    }
                }
                return filter(k, v);
            }


// Parsing happens in three stages. In the first stage, we run the text against
// a regular expression which looks for non-Analyzer characters. We are especially
// concerned with '()' and 'new' because they can cause invocation, and '='
// because it can cause mutation. But just to be safe, we will reject all
// unexpected characters.

// We split the first stage into 4 regexp operations in order to work around
// crippling inefficiencies in IE's and Safari's regexp engines. First we
// replace all backslash pairs with '@' (a non-Analyzer character). Second, we
// replace all simple value tokens with ']' characters. Third, we delete all
// open brackets that follow a colon or comma or that begin the text. Finally,
// we look to see that the remaining characters are only whitespace or ']' or
// ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval.

            if (/^[\],:{}\s]*$/.test(this.replace(/\\["\\\/bfnrtu]/g, '@').
                    replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']').
                    replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {

// In the second stage we use the eval function to compile the text into a
// JavaScript structure. The '{' operator is subject to a syntactic ambiguity
// in JavaScript: it can begin a block or an object literal. We wrap the text
// in parens to eliminate the ambiguity.

                j = eval('(' + this + ')');

// In the optional third stage, we recursively walk the new structure, passing
// each name/value pair to a filter function for possible transformation.

                return typeof filter === 'function' ? walk('', j) : j;
            }

// If the text is not Analyzer parseable, then a SyntaxError is thrown.

            throw new SyntaxError('parseAnalyzer');
        };


        s.toAnalyzerString = function () {

// If the string contains no control characters, no quote characters, and no
// backslash characters, then we can simply slap some quotes around it.
// Otherwise we must also replace the offending characters with safe
// sequences.

            if (/["\\\x00-\x1f]/.test(this)) {
                return '"' + this.replace(/[\x00-\x1f\\"]/g, function (a) {
                    var c = m[a];
                    if (c) {
                        return c;
                    }
                    c = a.charCodeAt();
                    return '\\u00' + Math.floor(c / 16).toString(16) +
                                               (c % 16).toString(16);
                }) + '"';
            }
            return '"' + this + '"';
        };
    })(String.prototype);
}

服务端解析：

List<MembersInfo> GetAnalysedMembersChanged(string strMembersChanged)
        {
            AnalyzerArray arrayMembersChanged = new AnalyzerArray();
            using (AnalyzerParser parser = new AnalyzerParser(new StringReader(strMembersChanged), true))
                arrayMembersChanged = parser.ParseArray();

            AnalyzerString DimID;
            AnalyzerString MembersID;
            AnalyzerArray PropertiesValue;

            List<MembersInfo> listMembersChanged = new List<MembersInfo>();

            foreach (AnalyzerObject s in arrayMembersChanged)
            {
                DimID = (AnalyzerString)s["DimID"];
                MembersID = (AnalyzerString)s["MembersID"];
                PropertiesValue = (AnalyzerArray)s["NewPropetiesValue"];

                AnalyzerString name;
                AnalyzerString type;
                AnalyzerString value;

                List<MemberPropety> memberProp = new List<MemberPropety>();
                foreach (AnalyzerObject obj in PropertiesValue)
                {
                    name = (AnalyzerString)obj["Name"];
                    type = (AnalyzerString)obj["Type"];
                    value = (AnalyzerString)obj["Value"];
                    memberProp.Add(new MemberPropety(name.Value, type.Value, value.Value));
                }

                listMembersChanged.Add(new MembersInfo(int.Parse(DimID.Value), MembersID.Value, memberProp));

            }

            return listMembersChanged;
        }

服务端组件代码：

 ----