Example #1
0
 private static CustomAttributeBuilder CreateWebServiceBindingAttribute(WsiProfiles wsiProfile)
 {
     ReflectionUtils.CustomAttributeBuilderBuilder cabb =
         new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(WebServiceBindingAttribute));
     if (wsiProfile == WsiProfiles.BasicProfile1_1)
     {
         cabb.AddPropertyValue("ConformsTo", wsiProfile);
     }
     return cabb.Build();
 }
Example #2
0
 private static CustomAttributeBuilder CreateWebServiceAttribute(string description, string name, string ns)
 {
     ReflectionUtils.CustomAttributeBuilderBuilder cabb =
         new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(WebServiceAttribute));
     if (StringUtils.HasText(description))
     {
         cabb.AddPropertyValue("Description", description);
     }
     if (StringUtils.HasText(name))
     {
         cabb.AddPropertyValue("Name", name);
     }
     if (StringUtils.HasText(ns))
     {
         cabb.AddPropertyValue("Namespace", ns);
     }
     return cabb.Build();
 }
Example #3
0
 private static CustomAttributeBuilder CreateServiceContractAttribute(string name, string ns, string configurationName,
     Type callbackContract, ProtectionLevel protectionLevel, SessionMode sessionMode)
 {
     ReflectionUtils.CustomAttributeBuilderBuilder scbb =
         new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(ServiceContractAttribute));
     if (StringUtils.HasText(name))
     {
         scbb.AddPropertyValue("Name", name);
     }
     if (StringUtils.HasText(ns))
     {
         scbb.AddPropertyValue("Namespace", ns);
     }
     if (StringUtils.HasText(configurationName))
     {
         scbb.AddPropertyValue("ConfigurationName", configurationName);
     }
     if (callbackContract != null)
     {
         scbb.AddPropertyValue("CallbackContract", callbackContract);
     }
     if (protectionLevel != ProtectionLevel.None)
     {
         scbb.AddPropertyValue("ProtectionLevel", protectionLevel);
     }
     if (sessionMode != SessionMode.Allowed)
     {
         scbb.AddPropertyValue("SessionMode", sessionMode);
     }
     return scbb.Build();
 }
            /// <summary>
            /// Creates a <see cref="SoapDocumentMethodAttribute"/> or a <see cref="SoapRpcMethodAttribute"/>
            /// that should be applied to proxy method.
            /// </summary>
            private static CustomAttributeBuilder CreateSoapMethodAttribute(Operation operation,
                OperationBinding operationBinding, SoapOperationBinding soapOperationBinding,
                XmlMembersMapping inputMembersMapping, XmlMembersMapping outputMembersMapping)
            {
                ReflectionUtils.CustomAttributeBuilderBuilder cabb;

                string inputMembersMappingElementName = inputMembersMapping.ElementName;
                string inputMembersMappingNamespace = inputMembersMapping.Namespace;

                if (soapOperationBinding.Style == SoapBindingStyle.Rpc)
                {
                    cabb = new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(SoapRpcMethodAttribute));
                }
                else
                {
                    cabb = new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(SoapDocumentMethodAttribute));
                    cabb.AddPropertyValue("ParameterStyle", SoapParameterStyle.Wrapped);
                }

                cabb.AddContructorArgument(soapOperationBinding.SoapAction);
                cabb.AddPropertyValue("Use", SoapBindingUse.Literal);

                if (inputMembersMappingElementName.Length > 0 &&
                    inputMembersMappingElementName != operation.Name)
                {
                    cabb.AddPropertyValue("RequestElementName", inputMembersMappingElementName);
                }

                if (inputMembersMappingNamespace != null)
                {
                    cabb.AddPropertyValue("RequestNamespace", inputMembersMappingNamespace);
                }

                if (outputMembersMapping == null)
                {
                    cabb.AddPropertyValue("OneWay", true);
                }
                else
                {
                    string outputMembersMappingElementName = outputMembersMapping.ElementName;
                    string outputMembersMappingNamespace = outputMembersMapping.Namespace;

                    if (outputMembersMappingElementName.Length > 0 &&
                        outputMembersMappingElementName != (operation.Name + "Response"))
                    {
                        cabb.AddPropertyValue("ResponseElementName", outputMembersMappingElementName);
                    }

                    if (outputMembersMappingNamespace != null)
                    {
                        cabb.AddPropertyValue("ResponseNamespace", outputMembersMappingNamespace);
                    }
                }

                return cabb.Build();
            }
            /// <summary>
            /// Creates a <see cref="WebServiceBindingAttribute"/> that should be applied to proxy type.
            /// </summary>
            private CustomAttributeBuilder CreateWebServiceBindingAttribute(Binding wsBinding)
            {
                ReflectionUtils.CustomAttributeBuilderBuilder cabb =
                    new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(WebServiceBindingAttribute));

                cabb.AddContructorArgument(this.wsBinding.Name);
                cabb.AddPropertyValue("Namespace", this.wsBinding.ServiceDescription.TargetNamespace);

                return cabb.Build();
            }
            protected override IList GetMethodReturnTypeAttributes(MethodInfo method)
            {
                IList attrs = base.GetMethodReturnTypeAttributes(method);

                // Add the XmlElementAttribute if needed
                if (operation.Messages.Output != null)
                {
                    if (method.ReturnType != typeof(void))
                    {
                        if (outputMembersMapping.Count > 0)
                        {
                            XmlMemberMapping outMemberMapping = outputMembersMapping[0];
                            bool useMemberName = (outMemberMapping.MemberName != operation.Name + "Result");
                            bool useNamespace = outMemberMapping.Namespace != outputMembersMapping.Namespace;
                            bool useTypeNamespace = outMemberMapping.TypeNamespace != XmlSchema.Namespace &&
                                                    outMemberMapping.TypeNamespace != outputMembersMapping.Namespace;
                            if (useMemberName || useNamespace || useTypeNamespace)
                            {
                                if (outMemberMapping.TypeName.StartsWith ("ArrayOf", StringComparison.Ordinal))
                                {
                                    if (useMemberName || useNamespace)
                                    {
                                        ReflectionUtils.CustomAttributeBuilderBuilder cabb =
                                            new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(XmlArrayAttribute));
                                        if (useMemberName)
                                        {
                                            cabb.AddPropertyValue("ElementName", outMemberMapping.MemberName);
                                        }
                                        if (useNamespace)
                                        {
                                            cabb.AddPropertyValue("Namespace", outMemberMapping.Namespace);
                                        }
                                        attrs.Add(cabb.Build());
                                    }
                                    if (useTypeNamespace)
                                    {
                                        ReflectionUtils.CustomAttributeBuilderBuilder cabb =
                                            new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(XmlArrayItemAttribute));
                                        cabb.AddPropertyValue("Namespace", outMemberMapping.TypeNamespace);
                                        attrs.Add(cabb.Build());
                                    }
                                }
                                else
                                {
                                    if (useMemberName || useNamespace)
                                    {
                                        ReflectionUtils.CustomAttributeBuilderBuilder cabb =
                                            new ReflectionUtils.CustomAttributeBuilderBuilder(typeof(XmlElementAttribute));
                                        if (useMemberName)
                                        {
                                            cabb.AddPropertyValue("ElementName", outMemberMapping.MemberName);
                                        }
                                        if (useNamespace)
                                        {
                                            cabb.AddPropertyValue("Namespace", outMemberMapping.Namespace);
                                        }
                                        attrs.Add(cabb.Build());
                                    }
                                }
                            }
                        }
                    }
                }

                return attrs;
            }