.NET SVCUTIL does not generate namespaces properly

Question

I have a WSDL document with 2 namespaces, and I am trying to generate proxy classes using SVCUTIL.EXE. For some reason, in the generated code the types get placed into default namespace, not in the correct name for mapping provided.

Here is my WSDL:

<?xml version='1.0' encoding='UTF-8'?>
<wsdl:definitions name="TestService" 
    targetNamespace="My.Namespace.1" 
    xmlns:ns1="http://schemas.xmlsoap.org/soap/http" 
    xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" 
    xmlns:tns="My.Namespace.1" 
    xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
    xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <wsdl:types>
        <xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="My.Namespace.1" xmlns:ns1="My.Namespace.2" xmlns:tns="My.Namespace.1" xmlns:xs="http://www.w3.org/2001/XMLSchema">
            <xs:import namespace="My.Namespace.2"/>

            <xs:element name="TestOpRequest" type="tns:TestOpRequest"/>
            <xs:element name="TestOpResponse" type="tns:TestOpResponse"/>

            <xs:complexType name="TestOpRequest">
                <xs:sequence>
                    <xs:element ref="ns1:Type1"/>
                </xs:sequence>
            </xs:complexType>

            <xs:complexType name="TestOpResponse">
                <xs:sequence>
                </xs:sequence>
            </xs:complexType>

        </xs:schema>
        <xs:schema attributeFormDefault="unqualified" elementFormDefault="qualified" targetNamespace="My.Namespace.2" xmlns:tns="My.Namespace.2" xmlns:xs="http://www.w3.org/2001/XMLSchema">
            <xs:element name="Type1" type="tns:Type1"/>

            <xs:complexType name="Type1">
                <xs:sequence>
                    <xs:element name="prop1" type="xs:string"/>
                    <xs:element name="prop2" type="xs:string"/>
                </xs:sequence>
            </xs:complexType>

        </xs:schema>
    </wsdl:types>

    <wsdl:message name="testOp">
        <wsdl:part element="tns:TestOpRequest" name="parameter"/>
    </wsdl:message>

    <wsdl:message name="testOpResponse">
        <wsdl:part element="tns:TestOpResponse" name="parameter"/>
    </wsdl:message>

    <wsdl:portType name="TestService">
        <wsdl:operation name="testOp">
            <wsdl:input message="tns:testOp" name="testOp"/>
            <wsdl:output message="tns:testOpResponse" name="testOpResponse"/>
        </wsdl:operation>
    </wsdl:portType>

    <wsdl:binding name="TestServiceSoapBinding" type="tns:TestService">
        <soap:binding style="document" transport="http://schemas.xmlsoap.org/soap/http"/>
        <wsdl:operation name="testOp">
            <soap:operation soapAction="" style="document"/>
            <wsdl:input name="testOp">
                <soap:body use="literal"/>
            </wsdl:input>
            <wsdl:output name="testOpResponse">
                <soap:body use="literal"/>
            </wsdl:output>
        </wsdl:operation>
    </wsdl:binding>
    <wsdl:service name="TestService">
        <wsdl:port binding="tns:TestServiceSoapBinding" name="TestServicePort">
            <soap:address location="http://localhost/TestService"/>
        </wsdl:port>
    </wsdl:service>
</wsdl:definitions>

Here is how I generate proxies:

SvcUtil.exe /t:code test.wsdl /n:My.Namespace.1,Test.Namespace1 /n:My.Namespace.2,Test.Namespace2 /o:Test.cs

Here is what gets generated:

/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("svcutil", "4.0.30319.1")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(Namespace="My.Namespace.1")]
public partial class TestOpRequest
{

    private Type1 type1Field;

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute(Namespace="My.Namespace.2", Order=0)]
    public Type1 Type1
    {
        get
        {
            return this.type1Field;
        }
        set
        {
            this.type1Field = value;
        }
    }
}

/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("svcutil", "4.0.30319.1")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(Namespace="My.Namespace.2")]
public partial class Type1
{

    private string prop1Field;

    private string prop2Field;

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute(Order=0)]
    public string prop1
    {
        get
        {
            return this.prop1Field;
        }
        set
        {
            this.prop1Field = value;
        }
    }

    /// <remarks/>
    [System.Xml.Serialization.XmlElementAttribute(Order=1)]
    public string prop2
    {
        get
        {
            return this.prop2Field;
        }
        set
        {
            this.prop2Field = value;
        }
    }
}

/// <remarks/>
[System.CodeDom.Compiler.GeneratedCodeAttribute("svcutil", "4.0.30319.1")]
[System.SerializableAttribute()]
[System.Diagnostics.DebuggerStepThroughAttribute()]
[System.ComponentModel.DesignerCategoryAttribute("code")]
[System.Xml.Serialization.XmlTypeAttribute(Namespace="My.Namespace.1")]
public partial class TestOpResponse
{
}
namespace Test.Namespace1
{


    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
    [System.ServiceModel.ServiceContractAttribute(Namespace="My.Namespace.1", ConfigurationName="Test.Namespace1.TestService")]
    public interface TestService
    {

        // CODEGEN: Generating message contract since the operation testOp is neither RPC nor document wrapped.
        [System.ServiceModel.OperationContractAttribute(Action="", ReplyAction="*")]
        [System.ServiceModel.XmlSerializerFormatAttribute()]
        Test.Namespace1.testOpResponse testOp(Test.Namespace1.testOp request);
    }

    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
    [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
    [System.ServiceModel.MessageContractAttribute(IsWrapped=false)]
    public partial class testOp
    {

        [System.ServiceModel.MessageBodyMemberAttribute(Namespace="My.Namespace.1", Order=0)]
        public TestOpRequest TestOpRequest;

        public testOp()
        {
        }

        public testOp(TestOpRequest TestOpRequest)
        {
            this.TestOpRequest = TestOpRequest;
        }
    }

    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
    [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
    [System.ServiceModel.MessageContractAttribute(IsWrapped=false)]
    public partial class testOpResponse
    {

        [System.ServiceModel.MessageBodyMemberAttribute(Name="TestOpResponse", Namespace="My.Namespace.1", Order=0)]
        public TestOpResponse TestOpResponse1;

        public testOpResponse()
        {
        }

        public testOpResponse(TestOpResponse TestOpResponse1)
        {
            this.TestOpResponse1 = TestOpResponse1;
        }
    }

    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
    public interface TestServiceChannel : Test.Namespace1.TestService, System.ServiceModel.IClientChannel
    {
    }

    [System.Diagnostics.DebuggerStepThroughAttribute()]
    [System.CodeDom.Compiler.GeneratedCodeAttribute("System.ServiceModel", "4.0.0.0")]
    public partial class TestServiceClient : System.ServiceModel.ClientBase<Test.Namespace1.TestService>, Test.Namespace1.TestService
    {

        public TestServiceClient()
        {
        }

        public TestServiceClient(string endpointConfigurationName) : 
                base(endpointConfigurationName)
        {
        }

        public TestServiceClient(string endpointConfigurationName, string remoteAddress) : 
                base(endpointConfigurationName, remoteAddress)
        {
        }

        public TestServiceClient(string endpointConfigurationName, System.ServiceModel.EndpointAddress remoteAddress) : 
                base(endpointConfigurationName, remoteAddress)
        {
        }

        public TestServiceClient(System.ServiceModel.Channels.Binding binding, System.ServiceModel.EndpointAddress remoteAddress) : 
                base(binding, remoteAddress)
        {
        }

        [System.ComponentModel.EditorBrowsableAttribute(System.ComponentModel.EditorBrowsableState.Advanced)]
        Test.Namespace1.testOpResponse Test.Namespace1.TestService.testOp(Test.Namespace1.testOp request)
        {
            return base.Channel.testOp(request);
        }

        public TestOpResponse testOp(TestOpRequest TestOpRequest)
        {
            Test.Namespace1.testOp inValue = new Test.Namespace1.testOp();
            inValue.TestOpRequest = TestOpRequest;
            Test.Namespace1.testOpResponse retVal = ((Test.Namespace1.TestService)(this)).testOp(inValue);
            return retVal.TestOpResponse1;
        }
    }
}

Here is what I need to generate:

namespace Test.Namespace2
{
    public partial class Type1
    {
        ....
    }
}

namespace Test.Namespace1
{
    public partial class TestOpRequest
    {
        private Test.Namespace2 type1Field;
        ...
    }

    public partial class TestOpResponse
    {
    }

    public interface TestService
    {
        Test.Namespace1.testOpResponse testOp(Test.Namespace1.testOp request);
    }

    public partial class testOp
    {
        ...
    }

    public partial class testOpResponse
    {
        ...
    }

}

Any suggestions will be appreciated.

Answer 1

You can specify what namespaces you would like to get generated:

svcutil /n:*,Test.Namespace1 (... other args for svcutil not shown)

This would map all namespaces to the same Test.Namespace1.

Of course, you can map individual namespaces, for example, if your service is defined like this:

[ServiceContract(Namespace = "http://test.com/wsdl/MyFirstService")]
public interface IMyFirstService
{
}

[ServiceContract(Namespace = "http://test.com/wsdl/MySecondService")]
public interface IMySecondService
{
}

You could map them individually with:

svcutil /n:http://test.com/wsdl/MyFirstService,Test.Namespace1 
        /n:http://test.com/wsdl/MySecondService,Test.Namespace2
(etc...)

For more info, take a look at this but if you run into issues also this