public void PriorityValidator2()
        {
            SoapExtensionTypeElement el = new SoapExtensionTypeElement();

            el.Priority = 0;
            el.Priority = Int32.MaxValue;
        }
        internal static SoapExtensionRuntimeConfig[][] GetTypeExtensions(Type serviceType)
        {
            if (globalExtensions == null)
            {
                InitializeGlobalExtensions();
            }

            SoapExtensionRuntimeConfig[][] exts = new SoapExtensionRuntimeConfig[2][];

            for (int group = 0; group < 2; group++)
            {
                ArrayList globList = globalExtensions[group];
                if (globList == null)
                {
                    continue;
                }
                exts [group] = new SoapExtensionRuntimeConfig [globList.Count];
                for (int n = 0; n < globList.Count; n++)
                {
                    SoapExtensionTypeElement   econf    = (SoapExtensionTypeElement)globList [n];
                    SoapExtensionRuntimeConfig typeconf = new SoapExtensionRuntimeConfig();
                    typeconf.Type = econf.Type;
                    SoapExtension ext = (SoapExtension)Activator.CreateInstance(econf.Type);
                    typeconf.InitializationInfo = ext.GetInitializer(serviceType);
                    exts [group][n]             = typeconf;
                }
            }
            return(exts);
        }
        public void GetSet()
        {
            SoapExtensionTypeElement el = new SoapExtensionTypeElement();

            el.Group = PriorityGroup.High;
            Assert.AreEqual(PriorityGroup.High, el.Group, "A1");

            el.Priority = 2;
            Assert.AreEqual(2, el.Priority, "A2");

            el.Type = typeof(string);
            Assert.AreEqual(typeof(string), el.Type, "A3");
        }
        public void Ctors()
        {
            SoapExtensionTypeElement el = new SoapExtensionTypeElement();

            Assert.AreEqual(PriorityGroup.Low, el.Group, "A1");
            Assert.AreEqual(0, el.Priority, "A2");
            Assert.IsNull(el.Type, "A3");

            el = new SoapExtensionTypeElement(typeof(string), 5, PriorityGroup.High);
            Assert.AreEqual(PriorityGroup.High, el.Group, "A4");
            Assert.AreEqual(5, el.Priority, "A5");
            Assert.AreEqual(typeof(string), el.Type, "A6");

            el = new SoapExtensionTypeElement("System.String", 5, PriorityGroup.High);
            Assert.AreEqual(PriorityGroup.High, el.Group, "A7");
            Assert.AreEqual(5, el.Priority, "A8");
            Assert.AreEqual(typeof(string), el.Type, "A9");
        }
 public void CopyTo(SoapExtensionTypeElement[] array, int index)
 {
 }
 // Methods
 public void Add(SoapExtensionTypeElement element)
 {
 }
 public void Remove(SoapExtensionTypeElement element)
 {
 }
 public int IndexOf(SoapExtensionTypeElement element)
 {
 }
 // Methods
 public void Add(SoapExtensionTypeElement element)
 {
 }
 public void Remove(SoapExtensionTypeElement element)
 {
 }
 public int IndexOf(SoapExtensionTypeElement element)
 {
 }
        public void PriorityValidator1()
        {
            SoapExtensionTypeElement el = new SoapExtensionTypeElement();

            el.Priority = -1;
        }
        internal SoapClientType(Type type)
        {
            this.binding = WebServiceBindingReflector.GetAttribute(type);
            if (this.binding == null)
            {
                throw new InvalidOperationException(Res.GetString(Res.WebClientBindingAttributeRequired));
            }
            // Note: Service namespace is taken from WebserviceBindingAttribute and not WebserviceAttribute because
            // the generated proxy does not have a WebServiceAttribute; however all have a WebServiceBindingAttribute.
            serviceNamespace        = binding.Namespace;
            serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type);
            ArrayList soapMethodList = new ArrayList();
            ArrayList mappings       = new ArrayList();

            GenerateXmlMappings(type, soapMethodList, serviceNamespace, serviceDefaultIsEncoded, mappings);
            XmlMapping[] xmlMappings = (XmlMapping[])mappings.ToArray(typeof(XmlMapping));

            TraceMethod caller = Tracing.On ? new TraceMethod(this, ".ctor", type) : null;

            if (Tracing.On)
            {
                Tracing.Enter(Tracing.TraceId(Res.TraceCreateSerializer), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", xmlMappings, type));
            }
            XmlSerializer[] serializers = XmlSerializer.FromMappings(xmlMappings, type);
            if (Tracing.On)
            {
                Tracing.Exit(Tracing.TraceId(Res.TraceCreateSerializer), caller);
            }

            SoapExtensionTypeElementCollection extensionTypes = WebServicesSection.Current.SoapExtensionTypes;
            ArrayList highPri = new ArrayList();
            ArrayList lowPri  = new ArrayList();

            for (int i = 0; i < extensionTypes.Count; i++)
            {
                SoapExtensionTypeElement element   = extensionTypes[i];
                SoapReflectedExtension   extension = new SoapReflectedExtension(extensionTypes[i].Type, null, extensionTypes[i].Priority);
                if (extensionTypes[i].Group == PriorityGroup.High)
                {
                    highPri.Add(extension);
                }
                else
                {
                    lowPri.Add(extension);
                }
            }

            HighPriExtensions = (SoapReflectedExtension[])highPri.ToArray(typeof(SoapReflectedExtension));
            LowPriExtensions  = (SoapReflectedExtension[])lowPri.ToArray(typeof(SoapReflectedExtension));
            Array.Sort(HighPriExtensions);
            Array.Sort(LowPriExtensions);
            HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, HighPriExtensions);
            LowPriExtensionInitializers  = SoapReflectedExtension.GetInitializers(type, LowPriExtensions);

            int count = 0;

            for (int i = 0; i < soapMethodList.Count; i++)
            {
                SoapReflectedMethod soapMethod   = (SoapReflectedMethod)soapMethodList[i];
                SoapClientMethod    clientMethod = new SoapClientMethod();
                clientMethod.parameterSerializer = serializers[count++];
                if (soapMethod.responseMappings != null)
                {
                    clientMethod.returnSerializer = serializers[count++];
                }
                clientMethod.inHeaderSerializer = serializers[count++];
                if (soapMethod.outHeaderMappings != null)
                {
                    clientMethod.outHeaderSerializer = serializers[count++];
                }
                clientMethod.action                = soapMethod.action;
                clientMethod.oneWay                = soapMethod.oneWay;
                clientMethod.rpc                   = soapMethod.rpc;
                clientMethod.use                   = soapMethod.use;
                clientMethod.paramStyle            = soapMethod.paramStyle;
                clientMethod.methodInfo            = soapMethod.methodInfo;
                clientMethod.extensions            = soapMethod.extensions;
                clientMethod.extensionInitializers = SoapReflectedExtension.GetInitializers(clientMethod.methodInfo, soapMethod.extensions);
                ArrayList inHeaders  = new ArrayList();
                ArrayList outHeaders = new ArrayList();
                for (int j = 0; j < soapMethod.headers.Length; j++)
                {
                    SoapHeaderMapping   mapping    = new SoapHeaderMapping();
                    SoapReflectedHeader soapHeader = soapMethod.headers[j];
                    mapping.memberInfo = soapHeader.memberInfo;
                    mapping.repeats    = soapHeader.repeats;
                    mapping.custom     = soapHeader.custom;
                    mapping.direction  = soapHeader.direction;
                    mapping.headerType = soapHeader.headerType;
                    if ((mapping.direction & SoapHeaderDirection.In) != 0)
                    {
                        inHeaders.Add(mapping);
                    }
                    if ((mapping.direction & (SoapHeaderDirection.Out | SoapHeaderDirection.Fault)) != 0)
                    {
                        outHeaders.Add(mapping);
                    }
                }
                clientMethod.inHeaderMappings = (SoapHeaderMapping[])inHeaders.ToArray(typeof(SoapHeaderMapping));
                if (clientMethod.outHeaderSerializer != null)
                {
                    clientMethod.outHeaderMappings = (SoapHeaderMapping[])outHeaders.ToArray(typeof(SoapHeaderMapping));
                }
                methods.Add(soapMethod.name, clientMethod);
            }
        }
Exemple #14
0
        internal SoapClientType(Type type)
        {
            this.binding = WebServiceBindingReflector.GetAttribute(type);
            if (this.binding == null)
            {
                throw new InvalidOperationException(Res.GetString("WebClientBindingAttributeRequired"));
            }
            this.serviceNamespace        = this.binding.Namespace;
            this.serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type);
            ArrayList soapMethodList = new ArrayList();
            ArrayList mappings       = new ArrayList();

            GenerateXmlMappings(type, soapMethodList, this.serviceNamespace, this.serviceDefaultIsEncoded, mappings);
            XmlMapping[] mappingArray = (XmlMapping[])mappings.ToArray(typeof(XmlMapping));
            TraceMethod  caller       = Tracing.On ? new TraceMethod(this, ".ctor", new object[] { type }) : null;

            if (Tracing.On)
            {
                Tracing.Enter(Tracing.TraceId("TraceCreateSerializer"), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", new object[] { mappingArray, type }));
            }
            XmlSerializer[] serializerArray = XmlSerializer.FromMappings(mappingArray, type);
            if (Tracing.On)
            {
                Tracing.Exit(Tracing.TraceId("TraceCreateSerializer"), caller);
            }
            SoapExtensionTypeElementCollection soapExtensionTypes = WebServicesSection.Current.SoapExtensionTypes;
            ArrayList list3 = new ArrayList();
            ArrayList list4 = new ArrayList();

            for (int i = 0; i < soapExtensionTypes.Count; i++)
            {
                SoapExtensionTypeElement element1  = soapExtensionTypes[i];
                SoapReflectedExtension   extension = new SoapReflectedExtension(soapExtensionTypes[i].Type, null, soapExtensionTypes[i].Priority);
                if (soapExtensionTypes[i].Group == PriorityGroup.High)
                {
                    list3.Add(extension);
                }
                else
                {
                    list4.Add(extension);
                }
            }
            this.HighPriExtensions = (SoapReflectedExtension[])list3.ToArray(typeof(SoapReflectedExtension));
            this.LowPriExtensions  = (SoapReflectedExtension[])list4.ToArray(typeof(SoapReflectedExtension));
            Array.Sort <SoapReflectedExtension>(this.HighPriExtensions);
            Array.Sort <SoapReflectedExtension>(this.LowPriExtensions);
            this.HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, this.HighPriExtensions);
            this.LowPriExtensionInitializers  = SoapReflectedExtension.GetInitializers(type, this.LowPriExtensions);
            int num2 = 0;

            for (int j = 0; j < soapMethodList.Count; j++)
            {
                SoapReflectedMethod method2 = (SoapReflectedMethod)soapMethodList[j];
                SoapClientMethod    method3 = new SoapClientMethod {
                    parameterSerializer = serializerArray[num2++]
                };
                if (method2.responseMappings != null)
                {
                    method3.returnSerializer = serializerArray[num2++];
                }
                method3.inHeaderSerializer = serializerArray[num2++];
                if (method2.outHeaderMappings != null)
                {
                    method3.outHeaderSerializer = serializerArray[num2++];
                }
                method3.action                = method2.action;
                method3.oneWay                = method2.oneWay;
                method3.rpc                   = method2.rpc;
                method3.use                   = method2.use;
                method3.paramStyle            = method2.paramStyle;
                method3.methodInfo            = method2.methodInfo;
                method3.extensions            = method2.extensions;
                method3.extensionInitializers = SoapReflectedExtension.GetInitializers(method3.methodInfo, method2.extensions);
                ArrayList list5 = new ArrayList();
                ArrayList list6 = new ArrayList();
                for (int k = 0; k < method2.headers.Length; k++)
                {
                    SoapHeaderMapping   mapping = new SoapHeaderMapping();
                    SoapReflectedHeader header  = method2.headers[k];
                    mapping.memberInfo = header.memberInfo;
                    mapping.repeats    = header.repeats;
                    mapping.custom     = header.custom;
                    mapping.direction  = header.direction;
                    mapping.headerType = header.headerType;
                    if ((mapping.direction & SoapHeaderDirection.In) != 0)
                    {
                        list5.Add(mapping);
                    }
                    if ((mapping.direction & (SoapHeaderDirection.Fault | SoapHeaderDirection.Out)) != 0)
                    {
                        list6.Add(mapping);
                    }
                }
                method3.inHeaderMappings = (SoapHeaderMapping[])list5.ToArray(typeof(SoapHeaderMapping));
                if (method3.outHeaderSerializer != null)
                {
                    method3.outHeaderMappings = (SoapHeaderMapping[])list6.ToArray(typeof(SoapHeaderMapping));
                }
                this.methods.Add(method2.name, method3);
            }
        }
        public SoapServerType(Type type, WebServiceProtocols protocolsSupported) : base(type)
        {
            this.methods            = new Hashtable();
            this.duplicateMethods   = new Hashtable();
            this.protocolsSupported = protocolsSupported;
            bool flag = (protocolsSupported & WebServiceProtocols.HttpSoap) != WebServiceProtocols.Unknown;

            LogicalMethodInfo[] methods   = WebMethodReflector.GetMethods(type);
            ArrayList           list      = new ArrayList();
            WebServiceAttribute attribute = WebServiceReflector.GetAttribute(type);
            object soapServiceAttribute   = SoapReflector.GetSoapServiceAttribute(type);

            this.routingOnSoapAction     = SoapReflector.GetSoapServiceRoutingStyle(soapServiceAttribute) == SoapServiceRoutingStyle.SoapAction;
            this.serviceNamespace        = attribute.Namespace;
            this.serviceDefaultIsEncoded = SoapReflector.ServiceDefaultIsEncoded(type);
            SoapReflectionImporter importer  = SoapReflector.CreateSoapImporter(this.serviceNamespace, this.serviceDefaultIsEncoded);
            XmlReflectionImporter  importer2 = SoapReflector.CreateXmlImporter(this.serviceNamespace, this.serviceDefaultIsEncoded);

            SoapReflector.IncludeTypes(methods, importer);
            WebMethodReflector.IncludeTypes(methods, importer2);
            SoapReflectedMethod[] methodArray = new SoapReflectedMethod[methods.Length];
            SoapExtensionTypeElementCollection soapExtensionTypes = WebServicesSection.Current.SoapExtensionTypes;
            ArrayList list2 = new ArrayList();
            ArrayList list3 = new ArrayList();

            for (int i = 0; i < soapExtensionTypes.Count; i++)
            {
                SoapExtensionTypeElement element = soapExtensionTypes[i];
                if (element != null)
                {
                    SoapReflectedExtension extension = new SoapReflectedExtension(element.Type, null, element.Priority);
                    if (element.Group == PriorityGroup.High)
                    {
                        list2.Add(extension);
                    }
                    else
                    {
                        list3.Add(extension);
                    }
                }
            }
            this.HighPriExtensions = (SoapReflectedExtension[])list2.ToArray(typeof(SoapReflectedExtension));
            this.LowPriExtensions  = (SoapReflectedExtension[])list3.ToArray(typeof(SoapReflectedExtension));
            Array.Sort <SoapReflectedExtension>(this.HighPriExtensions);
            Array.Sort <SoapReflectedExtension>(this.LowPriExtensions);
            this.HighPriExtensionInitializers = SoapReflectedExtension.GetInitializers(type, this.HighPriExtensions);
            this.LowPriExtensionInitializers  = SoapReflectedExtension.GetInitializers(type, this.LowPriExtensions);
            for (int j = 0; j < methods.Length; j++)
            {
                LogicalMethodInfo   methodInfo = methods[j];
                SoapReflectedMethod method     = SoapReflector.ReflectMethod(methodInfo, false, importer2, importer, attribute.Namespace);
                list.Add(method.requestMappings);
                if (method.responseMappings != null)
                {
                    list.Add(method.responseMappings);
                }
                list.Add(method.inHeaderMappings);
                if (method.outHeaderMappings != null)
                {
                    list.Add(method.outHeaderMappings);
                }
                methodArray[j] = method;
            }
            XmlMapping[] mappings = (XmlMapping[])list.ToArray(typeof(XmlMapping));
            TraceMethod  caller   = Tracing.On ? new TraceMethod(this, ".ctor", new object[] { type, protocolsSupported }) : null;

            if (Tracing.On)
            {
                Tracing.Enter(Tracing.TraceId("TraceCreateSerializer"), caller, new TraceMethod(typeof(XmlSerializer), "FromMappings", new object[] { mappings, base.Evidence }));
            }
            XmlSerializer[] serializerArray = null;
            if (AppDomain.CurrentDomain.IsHomogenous)
            {
                serializerArray = XmlSerializer.FromMappings(mappings);
            }
            else
            {
                serializerArray = XmlSerializer.FromMappings(mappings, base.Evidence);
            }
            if (Tracing.On)
            {
                Tracing.Exit(Tracing.TraceId("TraceCreateSerializer"), caller);
            }
            int num3 = 0;

            for (int k = 0; k < methodArray.Length; k++)
            {
                SoapServerMethod    method3 = new SoapServerMethod();
                SoapReflectedMethod method4 = methodArray[k];
                method3.parameterSerializer = serializerArray[num3++];
                if (method4.responseMappings != null)
                {
                    method3.returnSerializer = serializerArray[num3++];
                }
                method3.inHeaderSerializer = serializerArray[num3++];
                if (method4.outHeaderMappings != null)
                {
                    method3.outHeaderSerializer = serializerArray[num3++];
                }
                method3.methodInfo            = method4.methodInfo;
                method3.action                = method4.action;
                method3.extensions            = method4.extensions;
                method3.extensionInitializers = SoapReflectedExtension.GetInitializers(method3.methodInfo, method4.extensions);
                method3.oneWay                = method4.oneWay;
                method3.rpc        = method4.rpc;
                method3.use        = method4.use;
                method3.paramStyle = method4.paramStyle;
                method3.wsiClaims  = (method4.binding == null) ? WsiProfiles.None : method4.binding.ConformsTo;
                ArrayList list4 = new ArrayList();
                ArrayList list5 = new ArrayList();
                for (int m = 0; m < method4.headers.Length; m++)
                {
                    SoapHeaderMapping   mapping = new SoapHeaderMapping();
                    SoapReflectedHeader header  = method4.headers[m];
                    mapping.memberInfo = header.memberInfo;
                    mapping.repeats    = header.repeats;
                    mapping.custom     = header.custom;
                    mapping.direction  = header.direction;
                    mapping.headerType = header.headerType;
                    if (mapping.direction == SoapHeaderDirection.In)
                    {
                        list4.Add(mapping);
                    }
                    else if (mapping.direction == SoapHeaderDirection.Out)
                    {
                        list5.Add(mapping);
                    }
                    else
                    {
                        list4.Add(mapping);
                        list5.Add(mapping);
                    }
                }
                method3.inHeaderMappings = (SoapHeaderMapping[])list4.ToArray(typeof(SoapHeaderMapping));
                if (method3.outHeaderSerializer != null)
                {
                    method3.outHeaderMappings = (SoapHeaderMapping[])list5.ToArray(typeof(SoapHeaderMapping));
                }
                if ((flag && !this.routingOnSoapAction) && method4.requestElementName.IsEmpty)
                {
                    throw new SoapException(System.Web.Services.Res.GetString("TheMethodDoesNotHaveARequestElementEither1", new object[] { method3.methodInfo.Name }), new XmlQualifiedName("Client", "http://schemas.xmlsoap.org/soap/envelope/"));
                }
                if (this.methods[method4.action] == null)
                {
                    this.methods[method4.action] = method3;
                }
                else
                {
                    if (flag && this.routingOnSoapAction)
                    {
                        SoapServerMethod method5 = (SoapServerMethod)this.methods[method4.action];
                        throw new SoapException(System.Web.Services.Res.GetString("TheMethodsAndUseTheSameSoapActionWhenTheService3", new object[] { method3.methodInfo.Name, method5.methodInfo.Name, method4.action }), new XmlQualifiedName("Client", "http://schemas.xmlsoap.org/soap/envelope/"));
                    }
                    this.duplicateMethods[method4.action] = method3;
                }
                if (this.methods[method4.requestElementName] == null)
                {
                    this.methods[method4.requestElementName] = method3;
                }
                else
                {
                    if (flag && !this.routingOnSoapAction)
                    {
                        SoapServerMethod method6 = (SoapServerMethod)this.methods[method4.requestElementName];
                        throw new SoapException(System.Web.Services.Res.GetString("TheMethodsAndUseTheSameRequestElementXmlns4", new object[] { method3.methodInfo.Name, method6.methodInfo.Name, method4.requestElementName.Name, method4.requestElementName.Namespace }), new XmlQualifiedName("Client", "http://schemas.xmlsoap.org/soap/envelope/"));
                    }
                    this.duplicateMethods[method4.requestElementName] = method3;
                }
            }
        }