客户端构造:

 

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

}

 

 

 

客户端组件代码:

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 arraythe case of using Json in my working

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

 

 

 

服务端解析:

 

 

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

 

 

 

服务端组件代码:

 ----

相关文章: