private SoapArrayInfo ParseArrayType(string value) {
            if (value == null) {
                throw new ArgumentNullException(Res.GetString(Res.XmlMissingArrayType, CurrentTag()));
            }

            if (value.Length == 0) {
                throw new ArgumentException(Res.GetString(Res.XmlEmptyArrayType, CurrentTag()), "value");
            }
 
            char[] chars = value.ToCharArray();
            int charsLength = chars.Length;
        
            SoapArrayInfo soapArrayInfo = new SoapArrayInfo(); 
 
            // Parse backwards to get length first, then optional dimensions, then qname.
            int pos = charsLength - 1;
 
            // Must end with ]
            if (chars[pos] != ']') {
                throw new ArgumentException(Res.GetString(Res.XmlInvalidArraySyntax), "value");
            }
            pos--;   
 
            // Find [
            while (pos != -1 && chars[pos] != '[') {
                if (chars[pos] == ',')
                    throw new ArgumentException(Res.GetString(Res.XmlInvalidArrayDimentions, CurrentTag()), "value");
                pos--;
            }
            if (pos == -1) {
                throw new ArgumentException(Res.GetString(Res.XmlMismatchedArrayBrackets), "value");
            }
 
            int len = charsLength - pos - 2;
            if (len > 0) {
                string lengthString = new String(chars, pos + 1, len);
                try {
                    soapArrayInfo.length = Int32.Parse(lengthString, CultureInfo.InvariantCulture);
                }
                catch (Exception e) {
                    if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                        throw;
                    }
                    throw new ArgumentException(Res.GetString(Res.XmlInvalidArrayLength, lengthString), "value");
                }
            }
            else {
                soapArrayInfo.length = -1;
            }

            pos--;         

            soapArrayInfo.jaggedDimensions = 0;
            while (pos != -1 && chars[pos] == ']') {
                pos--;
                if (pos < 0)
                    throw new ArgumentException(Res.GetString(Res.XmlMismatchedArrayBrackets), "value");
                if (chars[pos] == ',')
                    throw new ArgumentException(Res.GetString(Res.XmlInvalidArrayDimentions, CurrentTag()), "value");
                else if (chars[pos] != '[')
                    throw new ArgumentException(Res.GetString(Res.XmlInvalidArraySyntax), "value");
                pos--;
                soapArrayInfo.jaggedDimensions++;
            }

            soapArrayInfo.dimensions = 1;
 
            // everything else is qname - validation of qnames?
            soapArrayInfo.qname = new String(chars, 0, pos + 1);
            return soapArrayInfo;
        }
 private SoapArrayInfo ParseSoap12ArrayType(string itemType, string arraySize)
 {
     string[] strArray;
     SoapArrayInfo info = new SoapArrayInfo();
     if ((itemType != null) && (itemType.Length > 0))
     {
         info.qname = itemType;
     }
     else
     {
         info.qname = "";
     }
     if ((arraySize != null) && (arraySize.Length > 0))
     {
         strArray = arraySize.Split(null);
     }
     else
     {
         strArray = new string[0];
     }
     info.dimensions = 0;
     info.length = -1;
     for (int i = 0; i < strArray.Length; i++)
     {
         if (strArray[i].Length > 0)
         {
             if (strArray[i] == "*")
             {
                 info.dimensions++;
             }
             else
             {
                 try
                 {
                     info.length = int.Parse(strArray[i], CultureInfo.InvariantCulture);
                     info.dimensions++;
                 }
                 catch (Exception exception)
                 {
                     if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
                     {
                         throw;
                     }
                     throw new ArgumentException(Res.GetString("XmlInvalidArrayLength", new object[] { strArray[i] }), "value");
                 }
             }
         }
     }
     if (info.dimensions == 0)
     {
         info.dimensions = 1;
     }
     return info;
 }
        private SoapArrayInfo ParseSoap12ArrayType(string itemType, string arraySize) {
            SoapArrayInfo soapArrayInfo = new SoapArrayInfo(); 

            if (itemType != null && itemType.Length > 0)
                soapArrayInfo.qname = itemType;
            else
                soapArrayInfo.qname = "";

            string[] dimensions;
            if (arraySize != null && arraySize.Length > 0)
                dimensions = arraySize.Split(null);
            else
                dimensions = new string[0];

            soapArrayInfo.dimensions = 0;
            soapArrayInfo.length = -1;
            for (int i = 0; i < dimensions.Length; i++) {
                if (dimensions[i].Length > 0) {
                    if (dimensions[i] == "*") {
                        soapArrayInfo.dimensions++;
                    }
                    else {
                        try {
                            soapArrayInfo.length = Int32.Parse(dimensions[i], CultureInfo.InvariantCulture);
                            soapArrayInfo.dimensions++;
                        }
                        catch (Exception e) {
                            if (e is ThreadAbortException || e is StackOverflowException || e is OutOfMemoryException) {
                                throw;
                            }
                            throw new ArgumentException(Res.GetString(Res.XmlInvalidArrayLength, dimensions[i]), "value");
                        }
                    }
                }
            }
            if (soapArrayInfo.dimensions == 0)
                soapArrayInfo.dimensions = 1; // default is 1D even if no arraySize is specified

            return soapArrayInfo;
        }
 private SoapArrayInfo ParseArrayType(string value)
 {
     if (value == null)
     {
         throw new ArgumentNullException(Res.GetString("XmlMissingArrayType", new object[] { this.CurrentTag() }));
     }
     if (value.Length == 0)
     {
         throw new ArgumentException(Res.GetString("XmlEmptyArrayType", new object[] { this.CurrentTag() }), "value");
     }
     char[] chArray = value.ToCharArray();
     int length = chArray.Length;
     SoapArrayInfo info = new SoapArrayInfo();
     int index = length - 1;
     if (chArray[index] != ']')
     {
         throw new ArgumentException(Res.GetString("XmlInvalidArraySyntax"), "value");
     }
     index--;
     while ((index != -1) && (chArray[index] != '['))
     {
         if (chArray[index] == ',')
         {
             throw new ArgumentException(Res.GetString("XmlInvalidArrayDimentions", new object[] { this.CurrentTag() }), "value");
         }
         index--;
     }
     if (index == -1)
     {
         throw new ArgumentException(Res.GetString("XmlMismatchedArrayBrackets"), "value");
     }
     int num3 = (length - index) - 2;
     if (num3 > 0)
     {
         string s = new string(chArray, index + 1, num3);
         try
         {
             info.length = int.Parse(s, CultureInfo.InvariantCulture);
             goto Label_0163;
         }
         catch (Exception exception)
         {
             if (((exception is ThreadAbortException) || (exception is StackOverflowException)) || (exception is OutOfMemoryException))
             {
                 throw;
             }
             throw new ArgumentException(Res.GetString("XmlInvalidArrayLength", new object[] { s }), "value");
         }
     }
     info.length = -1;
 Label_0163:
     index--;
     info.jaggedDimensions = 0;
     while ((index != -1) && (chArray[index] == ']'))
     {
         index--;
         if (index < 0)
         {
             throw new ArgumentException(Res.GetString("XmlMismatchedArrayBrackets"), "value");
         }
         if (chArray[index] == ',')
         {
             throw new ArgumentException(Res.GetString("XmlInvalidArrayDimentions", new object[] { this.CurrentTag() }), "value");
         }
         if (chArray[index] != '[')
         {
             throw new ArgumentException(Res.GetString("XmlInvalidArraySyntax"), "value");
         }
         index--;
         info.jaggedDimensions++;
     }
     info.dimensions = 1;
     info.qname = new string(chArray, 0, index + 1);
     return info;
 }