System.Runtime.Serialization.Formatters.Soap.SoapHandler.ProcessType C# (CSharp) Method

ProcessType() private method

private ProcessType ( ParseRecord pr, ParseRecord objectPr ) : void
pr ParseRecord
objectPr ParseRecord
return void
        private void ProcessType(ParseRecord pr, ParseRecord objectPr)
        {
            InternalST.Soap( this, "ProcessType nameXmlKey ",pr.PRnameXmlKey," typeXmlKey ",pr.PRtypeXmlKey);
            pr.Dump();
            if (pr.PRdtType != null)
                return;
            if ((pr.PRnameXmlKey.Equals(soapEnvKey)) && (String.Compare(pr.PRname, "Fault", StringComparison.OrdinalIgnoreCase) == 0))
            {
                // Fault object
                InternalST.Soap( this, "ProcessType SoapFault");
                pr.PRdtType = SoapUtil.typeofSoapFault;
                pr.PRparseTypeEnum = InternalParseTypeE.Object;
            }
            else if (pr.PRname != null)
            {
                InternalST.Soap( this, "ProcessType Attribute 1");              

                String interopAssemblyNameString = null;

                // determine interop assembly string if there is a namespace
                if ((pr.PRnameXmlKey != null) && (pr.PRnameXmlKey.Length > 0))
                {
                    interopAssemblyNameString = (String)assemKeyToInteropAssemblyTable[pr.PRnameXmlKey];
                    InternalST.Soap( this, "ProcessType Attribute 2 "+interopAssemblyNameString);               
                }

                // look for interop data
                Type type = null;
                String name = null;

                if (objectPr != null)
                {
                    if (pr.PRisXmlAttribute)
                    {
                        //  These should processed after containing element
                        //  is processed.
                        SoapServices.GetInteropFieldTypeAndNameFromXmlAttribute(
                                                                               objectPr.PRdtType, pr.PRname, interopAssemblyNameString,
                                                                               out type, out name);
                        InternalST.Soap( this, "ProcessType Attribute 3 type "+type+" name "+name);
                    }
                    else
                    {
                        SoapServices.GetInteropFieldTypeAndNameFromXmlElement(
                                                                             objectPr.PRdtType, pr.PRname, interopAssemblyNameString,
                                                                             out type, out name);
                        InternalST.Soap( this, "ProcessType Attribute 4 type objectPr.PRdtType ",objectPr.PRdtType," pr.PRname ",pr.PRname, " interopAssemblyNameString ",interopAssemblyNameString, " type ",type," name ",name);
                    }
                }

                if (type != null)
                {
                    pr.PRdtType = type;
                    pr.PRname = name;
                    pr.PRdtTypeCode = Converter.SoapToCode(pr.PRdtType);
                    InternalST.Soap(this, "ProcessType Attribute 5 typeCode "+((Enum)pr.PRdtTypeCode));
                }
                else
                {
                    if (interopAssemblyNameString != null)
                        pr.PRdtType = objectReader.Bind(interopAssemblyNameString, pr.PRname); // try to get type from SerializationBinder
                    if (pr.PRdtType == null)
                    {
                        pr.PRdtType = SoapServices.GetInteropTypeFromXmlElement(pr.PRname, interopAssemblyNameString);
                    }

                    // Array item where the element name gives the element type
                    if (pr.PRkeyDt == null && pr.PRnameXmlKey != null && pr.PRnameXmlKey.Length > 0 && objectPr.PRobjectTypeEnum == InternalObjectTypeE.Array && objectPr.PRarrayElementType == Converter.typeofObject)
                    {
                            pr.PRdtType = ProcessGetType(pr.PRname, pr.PRnameXmlKey, out pr.PRassemblyName);
                            pr.PRdtTypeCode = Converter.SoapToCode(pr.PRdtType);
                    }

                    InternalST.Soap(this, "ProcessType Attribute 6 type pr.PRname ", pr.PRname, " interopAssemblyNameString ",interopAssemblyNameString, " pr.PRdtType ",pr.PRdtType);
                }

            }

            if (pr.PRdtType != null)
                return;

            if ((pr.PRtypeXmlKey != null) && (pr.PRtypeXmlKey.Length > 0) && 
                (pr.PRkeyDt != null) && (pr.PRkeyDt.Length > 0) && 
                (assemKeyToInteropAssemblyTable.ContainsKey(pr.PRtypeXmlKey)))
            {
                InternalST.Soap(this, "ProcessType Attribute 7 ");
                // Interop type get from dtType
                int index = pr.PRkeyDt.IndexOf("[");
                if (index > 0)
                {
                    ProcessArray(pr, index, true);
                }
                else
                {
                    String assemblyString = (String)assemKeyToInteropAssemblyTable[pr.PRtypeXmlKey];
                    pr.PRdtType = objectReader.Bind(assemblyString, pr.PRkeyDt); // try to get type from SerializationBinder
                    if (pr.PRdtType == null)
                    {
                        pr.PRdtType = SoapServices.GetInteropTypeFromXmlType(pr.PRkeyDt, assemblyString); 
                        if (pr.PRdtType == null)
                            throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname+" "+pr.PRkeyDt));
                    }
                    InternalST.Soap(this, "ProcessType Attribute 8 type pr.PRkeyDt ",pr.PRkeyDt," pr.PRdtType ",pr.PRdtType);
                    if (pr.PRdtType == null)
                    {
                        throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname+" "+pr.PRkeyDt+", "+assemblyString));   
                    }
                }
            }
            else if (pr.PRkeyDt != null)
            {
                if (String.Compare(pr.PRkeyDt, "Base64", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    pr.PRobjectTypeEnum = InternalObjectTypeE.Array;
                    pr.PRarrayTypeEnum = InternalArrayTypeE.Base64;
                }
                else if (String.Compare(pr.PRkeyDt, "String", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    pr.PRdtType = SoapUtil.typeofString;
                }
                else if (String.Compare(pr.PRkeyDt, "methodSignature", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    // MethodSignature needs to be expanded to an array of types
                    InternalST.Soap( this, "ProcessType methodSignature ",pr.PRvalue);
                    try
                    {
                        pr.PRdtType = typeof(System.Type[]);
                        char[] c = {' ', ':'};
                        String[] typesStr = null;
                        if (pr.PRvalue != null)
                            typesStr = pr.PRvalue.Split(c);
                        Type[] types = null;
                        if ((typesStr == null) ||
                            (typesStr.Length == 1 && typesStr[0].Length == 0))
                        {
                            // Method signature with no parameters
                            types = new Type[0];
                        }
                        else
                        {
                            types = new Type[typesStr.Length/2];
                            //throw new SerializationException(String.Format(SoapUtil.GetResourceString("Serialization_MethodSignature"),pr.PRvalue));					

                            for (int i=0; i<typesStr.Length; i+=2)
                            {
                                String prefix = typesStr[i];
                                String typeString = typesStr[i+1];
                                types[i/2] = ProcessGetType(typeString, prefix, out pr.PRassemblyName);
                                InternalST.Soap( this, "ProcessType methodSignature type string ",i+" "+" prefix "+prefix+" typestring "+typeString+" type "+types[i/2]); //Temp
                            }
                        }
                        pr.PRvarValue = types;
                    }
                    catch {
                        throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_MethodSignature"),pr.PRvalue));
                    }
                }
                else
                {
                    pr.PRdtTypeCode = Converter.ToCode(pr.PRkeyDt);
                    if (pr.PRdtTypeCode != InternalPrimitiveTypeE.Invalid)
                    {
                        pr.PRdtType = Converter.SoapToType(pr.PRdtTypeCode);
                    }
                    else
                    {
                        // Find out if it is an array
                        int index = pr.PRkeyDt.IndexOf("[");
                        if (index > 0)
                        {
                            // Array
                            ProcessArray(pr, index, false);
                        }
                        else
                        {
                            // Object
                            pr.PRobjectTypeEnum = InternalObjectTypeE.Object;
                            pr.PRdtType = ProcessGetType(pr.PRkeyDt, pr.PRtypeXmlKey, out pr.PRassemblyName);
                            if ((pr.PRdtType == null) && (pr.PRobjectPositionEnum != InternalObjectPositionE.Top))
                                throw new SerializationException(String.Format(CultureInfo.CurrentCulture, SoapUtil.GetResourceString("Serialization_TypeElement"),pr.PRname+" "+pr.PRkeyDt));
                        }
                    }
                    InternalST.Soap(this, "ProcessType Attribute 9 type "+pr.PRdtType);
                }
            }
            else
            {
                if ((pr.PRparseTypeEnum == InternalParseTypeE.Object) && (!(objectReader.IsFakeTopObject && (pr.PRobjectPositionEnum == InternalObjectPositionE.Top))))
                {
                    if (String.Compare(pr.PRname, "Array", StringComparison.OrdinalIgnoreCase) == 0)
                        pr.PRdtType = ProcessGetType(pr.PRkeyDt, pr.PRtypeXmlKey, out pr.PRassemblyName);
                    else
                    {
                        pr.PRdtType = ProcessGetType(pr.PRname, pr.PRnameXmlKey, out pr.PRassemblyName);
                    }
                    InternalST.Soap(this, "ProcessType Attribute 10 type "+pr.PRdtType);
                }

            } 
        }