Two endpoint (soap ,json) and one service method

Question

I have that service

        [OperationContract]
    [WebGet(UriTemplate = "/GetData")]
    List<FieldInfo> GetSerializedData();

and web.config

<system.web>
    <webServices>
      <protocols>
        <add name="HttpGet" />
        <add name="HttpPost" />
      </protocols>
    </webServices>
    <httpRuntime  executionTimeout="90" maxRequestLength="1048576" useFullyQualifiedRedirectUrl="false" minFreeThreads="8" minLocalRequestFreeThreads="4" appRequestQueueLimit="100"/>
    <compilation debug="true" targetFramework="4.0"/>
  </system.web>
  <system.serviceModel>
    <bindings>
      <webHttpBinding>
        <binding name="webHttpBindingSettings" maxBufferPoolSize="524288" maxReceivedMessageSize="654321" sendTimeout="00:10:00" closeTimeout="00:01:00" openTimeout="00:10:00" receiveTimeout="00:10:00">
          <security mode="None">
            <transport clientCredentialType="None" />
          </security>
          <readerQuotas maxDepth="2147483647" maxStringContentLength="2147483647" maxArrayLength="2147483647" maxBytesPerRead="2147483647" maxNameTableCharCount="2147483647" />
        </binding>
      </webHttpBinding>
      <wsHttpBinding>
        <binding name="wsHttpBindingSettings" maxBufferPoolSize="524288" maxReceivedMessageSize="654321" sendTimeout="00:10:00" closeTimeout="00:01:00" openTimeout="00:10:00" receiveTimeout="00:10:00">
          <security mode="None">
            <transport clientCredentialType="None" />
          </security>
          <readerQuotas maxDepth="2147483647" maxStringContentLength="2147483647" maxArrayLength="2147483647" maxBytesPerRead="2147483647" maxNameTableCharCount="2147483647" />
        </binding>
      </wsHttpBinding>
    </bindings>
    <services>
      <service behaviorConfiguration="MetadataBehavior" name="ServiceModel.Service">
        <endpoint name="soap" address="soap" behaviorConfiguration="Default" binding="wsHttpBinding"
          bindingConfiguration="wsHttpBindingSettings" contract="ServiceModel.IService" />
        <endpoint name="Json" address="json" behaviorConfiguration="JSON" binding="webHttpBinding"
        bindingConfiguration="webHttpBindingSettings" contract="ServiceModel.IService" />
        <endpoint address="mex" binding="mexHttpBinding" contract="IMetadataExchange" />
        <host>
          <baseAddresses>
            <add baseAddress="http://service.com/Service.svc/" />
          </baseAddresses>
        </host>
      </service>
    </services>
    <behaviors>
      <serviceBehaviors>
        <behavior name="MetadataBehavior">
          <dataContractSerializer maxItemsInObjectGraph="2147483647"/>
          <serviceDebug includeExceptionDetailInFaults="true" />
          <serviceMetadata httpGetEnabled="true" />
        </behavior>
      </serviceBehaviors>
      <endpointBehaviors>
        <behavior name="JSON">
          <webHttp automaticFormatSelectionEnabled="true"/>
          <dataContractSerializer maxItemsInObjectGraph="10000000"/>
        </behavior>
        <behavior name="Default">
          <dataContractSerializer maxItemsInObjectGraph="10000000"/>
        </behavior>
      </endpointBehaviors>
    </behaviors>

Why on the client side only one endpoint is generated ?

    <client>
  <endpoint address="http://service.renault.com/Service.svc/soap"
    binding="wsHttpBinding" bindingConfiguration="soap" contract="ServiceReference1.IService"
    name="soap" />
</client>

My point is to execute service method from asp.net page codebehind and wcf return data in soap or json depends on ContentType. But how to set in asp.net page content type to application/json when it have text/html content. I have problem with understand it.

I think the problem is on the client side. Can you post details on the client calls ? — Steve B, Sep 09 '11 at 09:46

score 3 · Answer 1 · edited May 23 '17 at 12:04

3

Why on the client side only one endpoint is generated?

Because WCF does not emit metadata for non-SOAP endpoints. Unlike WSDL and MEX for SOAP, there's no widely used metadata format for "REST" endpoints (WADL is one of them, but it's not much used and not implemented by WCF), so on the Add Service Reference (or svcutil) will only see one endpoint in the metadata and only that one will be created.

I want to use WCF feature which select proper serialization type depends on ContentType of request

JSON vs XML is a serialization type decision; JSON vs SOAP is not (SOAP is a well-defined protocol, with rules for what the request should look like) - see more information on WCF Dynamic Response Format. Your webHttBinding-endpoint will do that (return JSON or XML based on the incoming request), since you enabled auto format selection, but the way you'd consume this service doesn't need to be with a WCF client - using WebClient, HttpWebRequest should work out just fine.

edited May 23 '17 at 12:04

Community

1
1

answered Sep 09 '11 at 13:28

carlosfigueira

85,035
14
131
171

Other problem is even if I add json endpoint to client when I test service in browser typed http://service.renault.com/Service.svc/soap/GetSerializedData or http://service.renault.com/Service.svc/json/GetSerializedData.Json result always was return when soap not and WCF Trace return " There is a problem with the XML that was received from the network. See inner exception for more details. ---> System.Xml.XmlException: The body of the message cannot be read because it is empty" – netmajor Sep 09 '11 at 14:08
1

You cannot use a browser to call a SOAP endpoint directly (i.e., typing the address on the address bar). All SOAP requests are made via HTTP POST, and the browser sends a GET request for addresses entered in its bar. – carlosfigueira Sep 09 '11 at 18:29

score 1 · Answer 2 · answered Sep 09 '11 at 10:03

If possible, try to design you Visual Studio like this :

Solution
- project with contracts (only the IXXXXService)
- web project with the implementation and all the endpoints (reference the contract project)
- clients project not using the VS generated proxy, but a factory that can select the correct endpoint and so protocol. (reference the contract project)

Here is a sample class I use in a scenario similar to yours :

public class ServiceHelper
{

    /// <summary>
    /// WCF proxys do not clean up properly if they throw an exception. This method ensures that the service 
    /// proxy is handeled correctly. Do not call TService.Close() or TService.Abort() within the action lambda.
    /// </summary>
    /// <typeparam name="TService">The type of the service to use</typeparam>
    /// <param name="action">Lambda of the action to performwith the service</param>
    [System.Diagnostics.DebuggerStepThrough]
    public static void UsingProxy<TService>(Action<TService> action)
        where TService : ICommunicationObject, IDisposable, new()
    {
        var service = new TService();
        bool success = false;
        try
        {
            action(service);
            if (service.State != CommunicationState.Faulted)
            {
                service.Close();
                success = true;
            }
        }
        finally
        {
            if (!success)
            {
                service.Abort();
            }
        }
    }
    /// <summary>
    /// WCF proxys do not clean up properly if they throw an exception. This method ensures that the service 
    /// proxy is handeled correctly. Do not call TService.Close() or TService.Abort() within the action lambda.
    /// </summary>
    /// <typeparam name="TIServiceContract">The type of the service contract to use</typeparam>
    /// <param name="action">Action to perform with the client instance.</param>
    /// <remarks>In the configuration, an endpoint with names that maches the <typeparamref name="TIServiceContract"/> name
    /// must exists. Otherwise, use <see cref="UsingContract&lt;TIServiceContract&gt;(string endpointName, Action<TIServiceContract> action)"/>. </remarks>
    [System.Diagnostics.DebuggerStepThrough]
    public static void UsingContract<TIServiceContract>(Action<TIServiceContract> action)
    {
        UsingContract<TIServiceContract>(
            typeof(TIServiceContract).Name,
            action
            );
    }
    /// <summary>
    /// WCF proxys do not clean up properly if they throw an exception. This method ensures that the service 
    /// proxy is handeled correctly. Do not call TService.Close() or TService.Abort() within the action lambda.
    /// </summary>
    /// <typeparam name="TIServiceContract">The type of the service contract to use</typeparam>
    /// <param name="action">Action to perform with the client instance.</param>
    /// <param name="endpointName">Name of the endpoint to use</param>
    [System.Diagnostics.DebuggerStepThrough]
    public static void UsingContract<TIServiceContract>(
          string endpointName,
          Action<TIServiceContract> action)
    {
        var cf = new ChannelFactory<TIServiceContract>(endpointName);
        var channel = cf.CreateChannel();
        var clientChannel = (IClientChannel)channel;

        bool success = false;
        try
        {
            action(channel);
            if (clientChannel.State != CommunicationState.Faulted)
            {
                clientChannel.Close();
                success = true;
            }
        }
        finally
        {
            if (!success) clientChannel.Abort();
        }
    }
}

In the client config, I set up manually my references :

<system.serviceModel>
<client>
  <endpoint address="http://localhost/myapp/myservice.svc/soap"
            binding="wsHttpBinding"
            contract="MyProject.Contracts.IMyService"
            name="IMyServiceSoap"/>
  <endpoint address="http://localhost/myapp/myservice.svc/rest"
            binding="webHttpBinding"
            contract="MyProject.Contracts.IMyService"
            name="IMyServiceRest"/>

</client>
</system.serviceModel>

Then, in your code you can simply call :

        ServiceHelper.UsingContract<"IMyServiceSoap", MyProject.Contracts.IMyService>(
            svc => svc.DoTheJob()
            );

or

        ServiceHelper.UsingContract<"IMyServiceRest", MyProject.Contracts.IMyService>(
            svc => svc.DoTheJob()
            );

[edit] The server config is similar to this one :

<services>
<service name="MyService">
    <endpoint address="soap"
    binding="wsHttpBinding"
                        contract="MyContracts.IMyService"/>
    <endpoint address="rest"
    binding="webHttpBinding"
                        contract="MyContracts.IMyService"/>
    <endpoint address="mex"
                        binding="mexHttpBinding"
                        contract="IMetadataExchange"/>
</service>
</services>

But in Your solution soap or json serialization depends from me, but I want to use WCF feature which select proper serialization type depends on ContentType of request — netmajor, Sep 09 '11 at 10:19
the serialization type is dependent of the endpoint (and its binding). There is no way to change the kind of serialization of single endpoint. I may be missing something, what does determine the content type of the request ? in other words, what are conditions of using the soap protocol or the rest protocol ? — Steve B, Sep 09 '11 at 10:21
My service was invoke on asp.net page and depend Accept Type (application/json or application/soap+xml) should return proper data. For now I get json but soap failed — netmajor, Sep 09 '11 at 14:33

Two endpoint (soap ,json) and one service method

2 Answers2

Linked