Sending large messages to a WCF Service

It took me several hours to sort out a problem when sending large messages to a WCF web service, looking for information at various websites. So I thought I’d summarise everything you need to do in one blog post.

We were getting errors such as “Bad Request” (HTTP Status 400) and .NET exceptions such as “System.ServiceModel.CommunicationException: The underlying connection was closed: The connection was closed unexpectedly. System.Net.WebException: The underlying connection was closed: The connection was closed unexpectedly”.

The fixes are all in the web.config
First configure the HTTP Runtime to accept large messages. Note – this is a denial of service risk. Our services are internal so I didn’t need to worry about this.

<system.web>
     <httpRuntime maxRequestLength="2097151" />
</system.web>

The rest of the configuration changes are in ServiceModel section. 2147483647 is the maximum for many values (the config items are Int32).
The config below will allow you to send a a large message. A large message that contains lots of objects (hence the maxItemsInObjectGraph) is streamed (transferMode=”Streamed”) in 0.5MB chunks (maxBufferSize=”524288″).The readerQuotas section allows large messages to be deserialized from XML into the service type.

<system.serviceModel>    
    <services>
	<service behaviorConfiguration="IncreasedItemsInObjectGraph"    
            name="ServiceName">
	    <endpoint address="" binding="basicHttpBinding" contract="ServiceName.IServiceContract" 
                   bindingConfiguration="BasicHttpBinding_IncreasedMessageSize_Buffered" />
	</service>
    </services>
    <behaviors>
	<servicebehaviors>
	   <behavior name="IncreasedItemsInObjectGraph">
		<servicemetadata httpGetEnabled="true" />
		<servicedebug includeExceptionDetailInFaults="true" />
			<datacontractserializer maxItemsInObjectGraph="2147483647" />
	   </behavior>
	</servicebehaviors>
    </behaviors>
    <bindings>
	<basichttpbinding>
		<binding name="BasicHttpBinding_IncreasedMessageSize_Buffered" 
                     maxBufferSize="524288" maxReceivedMessageSize="2147483647" 
                     closeTimeout="00:01:00" openTimeout="00:01:00" receiveTimeout="00:05:00" 
                     sendTimeout="00:05:00" transferMode="Streamed">
                     
                     <readerquotas maxDepth="2147483647" maxStringContentLength="2147483647"
                      maxArrayLength="2147483647" maxBytesPerRead="2147483647" 
                      maxNameTableCharCount="2147483647" />
		</binding>
	</basichttpbinding>
</bindings>
</system.serviceModel>

The client also needs similar settings:

<system.serviceModel>
	<bindings>
		<basichttpbinding>
			<binding name="BasicHttpBinding_IncreasedMessageSize_Buffered" closeTimeout="00:01:00" openTimeout="00:01:00" receiveTimeout="00:05:00" sendTimeout="00:05:00" transferMode="Streamed" maxBufferSize="524288" maxReceivedMessageSize="2147483647">
				<readerquotas maxDepth="2147483647" maxStringContentLength="2147483647" maxArrayLength="2147483647" maxBytesPerRead="2147483647" maxNameTableCharCount="2147483647" />
			</binding>
		</basichttpbinding>
	</bindings>
    <behaviors>
      <endpointbehaviors>
        <behavior name="MoreItemsInObjectGraph">
          <datacontractserializer maxItemsInObjectGraph="2147483647" />
        </behavior>        
      </endpointbehaviors>
    </behaviors>
	<client>
		<endpoint address="http://localhost:409/Service.svc" binding="basicHttpBinding" contract="Service.IServiceContract" bindingConfiguration="BasicHttpBinding_IncreasedMessageSize_Buffered" behaviorConfiguration="MoreItemsInObjectGraph"/>      
	</client>
</system.serviceModel>

Mocking WCF Services with Rhino Mocks

With WCF self-hosting it is easy to substitute an external service dependency with a mock service.
If you have code that calls an external web service, and you want to create an integration test that ensures that the external web service is called with the correct data, you can combine WCF self-hosting and a mocking framework to replace the external web service.
First, let’s create a pretend external web service that has one method that receives a complex type.

namespace TheService
{
    [ServiceContract]
    public interface IService
    {
        [OperationContract]
        Acknowledgement SubmitOrder(Order order);
    }

    [DataContract]
    public class Order {
        [DataMember]
        public int Id { get; set; }
        [DataMember]
        public IList OrderLines { get; set; }
    }

    [DataContract]
    public class OrderLine {
        [DataMember]
        public int Id { get; set; }
        [DataMember]
        public string Description { get; set; }
    }
}

The system under test uses this web service:

namespace TheClient {
    public class Facade {
        public bool SubmitOrder() {
            var order=new Order();
            order.Id = 1;
            order.OrderLines=new List();
            order.OrderLines.Add(new OrderLine{Description = "OrderLine1",Id = 1});
            order.OrderLines.Add(new OrderLine{Description = "OrderLine2",Id = 2});
            Acknowledgement acknowledgement;
            using (var serviceClient=new ServiceClient()) {
                acknowledgement = serviceClient.SubmitOrder(order);
            }
            return acknowledgement.Success;
        }
    }
}

Now we can write an integration test that makes sure we call the service with two order lines. First I create a class that implements the service contract. The methods do not need to be implemented as we will use Rhino Mocks to mock the behaviour – however notice that I had to make the method virtual so that I can use PartialMock. Also note the InstanceContextMode. It needs to set to “single” so that a mock service object can be loaded by ServiceHost.

namespace IntegrationTests {
   [ServiceBehavior(InstanceContextMode = InstanceContextMode.Single)]
    public class PartialMockService : IService {
        public virtual Acknowledgement SubmitOrder(Order order) {
            throw new NotImplementedException();
        }
    }
}

Now I can create the test. The mock needs to be set up in the TestFixtureSetup so that the service is running throughout all the tests.
The test sets up expectations on the service mock, and checks the arguments that were sent to the service method.

    [TestFixture]
    public class PartialMockTheService {
        private ServiceHost host;
        private MockRepository mockRepository;
        private PartialMockService serviceMock;

        [TestFixtureSetUp]
        public void TestFixtureSetUp() {
            mockRepository = new MockRepository();
            serviceMock = mockRepository.PartialMock<PartialMockService>();
            host = new ServiceHost(serviceMock);
            host.AddServiceEndpoint(typeof (IService), new BasicHttpBinding(), "http://localhost:8093/Service.svc");
            host.Open();
        }

        [Test]
        public void FacadeShouldCallTheWebserviceWithTwoOrderLines() {
            serviceMock.Expect(x => x.SubmitOrder(new Order()))
                            .IgnoreArguments()
                            .Return(new Acknowledgement {Success = true});
            mockRepository.ReplayAll();
            var facade = new Facade();

            Assert.IsTrue(facade.SubmitOrder());
            IList argumentsForCallsMadeOn = serviceMock
                              .GetArgumentsForCallsMadeOn(x => x.SubmitOrder(null));
            var order = (Order) argumentsForCallsMadeOn[0][0];
            Assert.AreEqual(2, order.OrderLines.Count);
        }
    }
}

The unit test app.config needs the same Service Model confiuration settings as the system under test, with the service location altererd so that it points to your mock rather than the real service.

<system.serviceModel>
        <client>
            <endpoint 
                    address="http://localhost:8093/Service.svc" 
                    binding="basicHttpBinding" 
                    contract="TheServiceProxy.IService" />
      </client>
</system.serviceModel>

I tried to do the same test but with DynamicMock rather than PartialMock. If you can get this to work you save some code as you won’t need to create PartialMockService. However, I could not get this to work. I got the error:

The service class of type IServiceProxyc688097f68fa4881a2eac45ad09283ba both defines a ServiceContract and inherits a ServiceContract from type TheService.IService. Contract inheritance can only be used among interface types. If a class is marked with ServiceContractAttribute, it must be the only type in the hierarchy with ServiceContractAttribute.

Basically, it appears as though the ServiceContract attribute is on both interface and dynamically created concrete. I did some brief investigation and I don’t think the problem is inside Rhino Mocks – I think it is in Castle’s DymanicProxy code that Rhino Mocks uses.