<?xml version="1.0" encoding="utf-8" ?>
<xsd:schema targetNamespace="urn:MyExternalSchema" xmlns:xsd="http://
  www.w3.org/2001/XMLSchema">
    <xsd:complexType name="MyExternalDatatype">
        <xsd:sequence>
            <xsd:element minOccurs="1" maxOccurs="1" name="MyString" 
              type="xsd:string" />
            <xsd:element minOccurs="1" maxOccurs="1" name="MyInt" 
              type="xsd:int" />
            <xsd:element minOccurs="1" maxOccurs="1" name="MyBool" 
              type="xsd:boolean" />
        </xsd:sequence>
    </xsd:complexType>
</xsd:schema>

using System.Web.Services;
using SShort.Xml.Serialization;

public class MyWebService : WebService
{
    [WebMethod]
    public void MyWebMethod(MyType param1)
    {
    }
}

[XmlImportedType("urn:my-schema", "MySchema.xsd", TypeName="MyExternalDatatype")]
public class MyType
{
    public string    MyString;
    public int    MyInt;
    public bool    MyBool;
}

<?xml version="1.0" encoding="utf-8" ?>
<xsd:schema targetNamespace="urn:SomeIndustryStandardsOrganization" 
  xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <xsd:element name="PurchaseOrder">
    <xsd:complexType>
      <xsd:sequence>
        <xsd:element minOccurs="1" maxOccurs="1" name="CompanyName" 
          type="xsd:string" />
        <xsd:element minOccurs="1" maxOccurs="1" name="MyInt" 
          type="xsd:int" />
        <xsd:element minOccurs="1" maxOccurs="1" name="Items">
          <xsd:complexType>
            <xsd:sequence>
              <xsd:element minOccurs="1" maxOccurs="unbounded" 
                name="Item">
                <xsd:complexType>
                  <xsd:sequence>
                    <xsd:element minOccurs="1" maxOccurs="1" 
                      name="Quantity" type="xsd:int" />
                    <xsd:element minOccurs="1" maxOccurs="1" 
                      name="UnitPrice" type="xsd:double" />
                    <xsd:element minOccurs="1" maxOccurs="1" 
                      name="ExtendedPrice" type="xsd:double"
                    />
                  </xsd:sequence>
                    <xsd:attribute name="sku" type="xsd:string" />
                </xsd:complexType>
              </xsd:element>
            </xsd:sequence>
          </xsd:complexType>
        </xsd:element>
      </xsd:sequence>
        <xsd:attribute name="id" type="xsd:string" />
    </xsd:complexType>
  </xsd:element>
</xsd:schema>

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, 
  Inherited = false, AllowMultiple = false)]
public class XmlImportedTypeAttribute : XmlTypeAttribute
{
    private string schemaLocation;

    public XmlImportedTypeAttribute(string xmlNamespace, string 
      schemaLocation)
    {
        base.Namespace = xmlNamespace;
        this.schemaLocation = schemaLocation;
    }

    public string SchemaLocation
    {
        get { return schemaLocation; }
        set { schemaLocation = value; }
    }
}

// Processes the XmlImportedXxx attributes for an individual Web method.
public override void ReflectMethod()
{
    this.reflectMethodCallCount++;

    // If it hasn't already been done, count the number of Web methods 
    // that do not reference an externally defined binding.
    if(this.totalReflectMethodCalls == -1)
    {
        this.totalReflectMethodCalls = this.GetTotalRefectMethodCalls();
    }

    // Process the return parameter and its type.
    this.ProcessReturnParameter();

    // Process each parameter in the method signature.
    this.ProcessMethodParameters();

    // Process the method's SOAP headers.
    this.ProcessSoapHeaders();

    // If this is the last call to ReflectMethod, then process the 
    // imports. 
    // Note:  The code to modify the WSDL document needs to be 
    //        run after all of the Web methods have been processed.
    //        When the framework provides a better interception point, 
    //        this code should be relocated accordingly.
    if(this.reflectMethodCallCount == this.totalReflectMethodCalls)
    {
        this.ProcessImportedNamespaces();
    }
}

// Process the return parameter and its type.
// - Process XmlImportedElement attribute on the return parameter.
// - Process XmlImportedRoot and XmlImportedType attributes on the return 
// parameter type.
// - Process the members of the return parameter type.
private void ProcessReturnParameter()
{
    // Process the return parameter for the XmlImportedElement attribute.
    // Note:  The method name ReturnTypeCustomAttributeProvider is 
    //        confusing because it is really the custom attribute 
    //        provider for the return parameter, not the return parameter 
    //        type.
    object [] importedElementAttributes = this.ReflectionContext
        .Method.ReturnTypeCustomAttributeProvider.GetCustomAttributes
        (typeof(XmlImportedElementAttribute), false);
    if(importedElementAttributes.Length > 0)
    {
        // Note:  If length is > 0, then I can assume that the length is 
        //        1 since the AllowMultiple property is set to false.
        XmlImportedElementAttribute importedElementAttribute = 
            (XmlImportedElementAttribute)importedElementAttributes[0];
        this.AddImportedNamespace(importedElementAttribute.Namespace, 
            importedElementAttribute.SchemaLocation);
    }

    // Process the return parameter type for the XmlImportedRoot 
    // attribute.
    object [] importedRootAttributes = 
        this.ReflectionContext.Method.ReturnType.GetCustomAttributes
        (typeof(XmlImportedRootAttribute), false);
    if(importedRootAttributes.Length > 0)
    {
        // Note:  If length is > 0, then I can assume that the length is 
        //        1 since the AllowMultiple property is set to false.
        XmlImportedRootAttribute importedRootAttribute = 
            (XmlImportedRootAttribute)importedRootAttributes[0];
        this.AddImportedNamespace(importedRootAttribute.Namespace, 
            importedRootAttribute.SchemaLocation);
    }

    // Process the return parameter type for the XmlImportedType 
    // attribute.
    object [] importedTypeAttributes = 
        this.ReflectionContext.Method.ReturnType.GetCustomAttributes
        (typeof(XmlImportedTypeAttribute), false);
    if(importedTypeAttributes.Length > 0)
    {
        // Note:  If length is > 0, then I can assume that the length is 
        //        1 since the AllowMultiple property is set to false.
        XmlImportedTypeAttribute importedTypeAttribute = 
            (XmlImportedTypeAttribute)importedTypeAttributes[0];
        this.AddImportedNamespace(importedTypeAttribute.Namespace, 
            importedTypeAttribute.SchemaLocation);
    }

    // Process the members of the return type.
    this.ProcessTypeMembers(this.ReflectionContext.Method.ReturnType);
}

// Count the number of Web methods that do not reference an externally 
// defined binding. Note: ReflectMethod is called by the runtime for 
// each Web method exposed by the Web Service that is not also decorated 
// with the WebServiceBinding attribute.
protected int GetTotalRefectMethodCalls()
{
    int count = 0;

    MethodInfo [] methodInfos = 
        this.ReflectionContext.ServiceType.GetMethods();
    foreach(MethodInfo methodInfo in methodInfos)
    {
        // If this is a Web method and it , increment the count.
        if(methodInfo.GetCustomAttributes(typeof(WebMethodAttribute), 
        false).Length > 0)
        {
            // Determine if the Web method references an externally 
            // defined binding. If so, don't include it in the count.
            Object [] docAttributes = 
                methodInfo.GetCustomAttributes
                (typeof(SoapDocumentMethodAttribute), false);
            if(docAttributes.Length > 0)
            {
                SoapDocumentMethodAttribute docAttribute = 
                    (SoapDocumentMethodAttribute)docAttributes[0];
                if(docAttribute.Binding == null || docAttribute.Binding 
                  == "")
                {
                    count++;
                }
            }
            else
            {
                count++;
            }
        }
    }

    return count;
}

// Modifies the WSDL document generated by the runtime so that it 
// properly imports external schemas.
public void ProcessImportedNamespaces()
{
    foreach(DictionaryEntry importedNamespace in this.importedNamespaces)
    {
        // If the datatype is defined within the schema, remove it and 
        // import it instead.
        XmlSchema externalSchema = 
            this.ReflectionContext.ServiceDescription.Types.Schemas[(string)
            importedNamespace.Key];
        if (externalSchema != null) 
        {
            // Remove the schema containing the externally defined 
            // datatypes.
            ReflectionContext.ServiceDescription
                .Types.Schemas.Remove(externalSchema);

            // Import the schema into the WSDL document.
            // Note:  Setting the schemaLocation attribute in the schema 
            //        that uses the type should be sufficient.  However, 
            //        WSDL.exe currently has a bug (#108843) that 
            //        requires that a WSDL import element be defined.
            //        Otherwise, I would only need to do so if the WSDL 
            //        document directly references entities defined 
            //        within the external schema.
            Import import = new Import();
            import.Namespace = (string)importedNamespace.Key;
            import.Location = (string)importedNamespace.Value;
            ReflectionContext.ServiceDescription.Imports.Add(import);
        }
    }

    // Modify the import statements in all remaining schemas.
    foreach(XmlSchema schema in 
        this.ReflectionContext.ServiceDescription.Types.Schemas)
    {
        foreach(XmlSchemaImport importedSchema in schema.Includes)
        {
            if(this.importedNamespaces.ContainsKey(importedSchema.Namespace))
            {
                // Add the schemaLocation attribute to the import 
                // element.
                importedSchema.SchemaLocation = 
                    (string)this.importedNamespaces[importedSchema.Namespace];
            }
        }
    }
}