Code Reference A collection of code for my reference (and perhaps other people too)

Add a POST method to the WCF service

NOTE: This continues the series from the post Read the GET request parameters in the AfterReceiveRequest() method

I changed the name of the SchemeTest() method to SimpleTest() because the scheme test will be done on the POST request sending XML, not on a GET request.

Here is the new interface:

namespace WCFServiceWithScheme
{
    [ServiceContract]
    public interface ITestService
    {
        [OperationContract]
        [WebGet(UriTemplate = "SimpleTest?name={name}")]
        string SimpleTest(string name);

        [OperationContract]
        [WebInvoke(Method = "POST", UriTemplate = "SchemeTest",
           BodyStyle = WebMessageBodyStyle.Bare,
           RequestFormat = WebMessageFormat.Xml)]
        string SchemeTest(RequestObject theRequest);
    }
}

Here are the new public methods:

namespace WCFServiceWithScheme
{
    public class TestService : ITestService
    {
        public string SimpleTest(string name)
        {
            return "The name is " + name;
        }

        public string SchemeTest(RequestObject theRequest)
        {
            return "nothing interesting";
        }
    }
}

We have to create the simple object that will be POSTed in the request. I called it 'RequestObject'.
Notice we have included a namespace in the DataContract. This will also have to be sent in the request to the service.

namespace WCFServiceWithScheme
{
    [DataContract(Namespace = "http://WCFServiceWithScheme")]
    public class RequestObject
    {
        [DataMember]
        public string FirstName { get; set; }
        [DataMember]
        public string LastName { get; set; }
        [DataMember]
        public short Age
        {
            get { return age; }
            set { age = value; }
        }

        private short age = 0;
    }
}

The XML submitted for this object is here. Notice the namespace is included.

<?xml version="1.0" encoding="utf-8" ?>
<RequestObject xmlns="http://WCFServiceWithScheme">
     <Age>21</Age>
     <FirstName>Howard</FirstName>
     <LastName>Lumpy</LastName>
</RequestObject>

Read GET request parameters in the AfterReceiveRequest() method

NOTE: This continues the series from the post Expand the simple service with IDispatchMessageInspector

On a GET request, the relevant data is in the parameters. Here is how to read this data:

• Determine the request's mothod (GET or POST)
  You don't know what method is called or how it was called.
• Get the URITemplateMatchResults
• Get the operation name (method) that was called.
• Get the RequestUri
• Loop thru the Querry Parameters
• Loop thru the Bound Variables

NOTE: Any request to the service will run thru there. If you have 10 different GET and POST methods in your service, a request to any of them will go thru here before it goes to the called method.

public object AfterReceiveRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel, System.ServiceModel.InstanceContext instanceContext)
{
    // Get the request message from the request
    HttpRequestMessageProperty requestMessage = request.Properties["httpRequest"] as HttpRequestMessageProperty;
    string method = string.Empty;
    if (requestMessage != null)
    {
        // The method will be GET or POST.
        method = requestMessage.Method;
    }

    // Get the UriTemplateMatchResults from the request.
    // Here you can see some of the fun things that are revealed.
    UriTemplateMatch results = internalCopy.Properties["UriTemplateMatchResults"] as UriTemplateMatch;
    if (results != null)
    {
        // Get the operation name from the request.
        // Here you can see what method was called in the Service.
        // Since we have only one method (SchemeTest), it should be this.
        // We can add a simple 'HelloWorld' method to see this value change.
        string operationName = string.Empty;
        if (results.RelativePathSegments.Count > 0)
            operationName = results.RelativePathSegments[results.RelativePathSegments.Count - 1];

        //
        string requestUri = results.RequestUri.ToString();

        // If the request method is GET, then you can play with the query parameters, uri template, and bound variables
        if (method == "GET")
        {

            // Loop thru the querry parameters
            NameValueCollection queryParameters = results.QueryParameters;
            foreach (var p in queryParameters)
            {
                Console.WriteLine(p);
            }

            // The Uri template is the same as in the Attribute of the interface: [WebGet(UriTemplate = "SchemeTest?name={name}")]
            string template = results.Template.ToString();

            // You can loop thru the key in the variables passed in.
            NameValueCollection boundVariables = results.BoundVariables;
            foreach (string key in boundVariables.AllKeys)
            {
                // Variable names are always in UPPER case. Don't know why.
                if (key == "NAME")
                    Console.WriteLine("This is the 'name' key");
            }
        }

       Object correlationState = new object();
       return correlationState;
}

CreateBufferedCopy of request in MessageInspector of WCF Service

NOTE: This continues the series from Expand the simple service with IDispatchMessageInspector

When your web service is called, before the request reaches the main service method, the 'AfterReceiveRequest()' method is fired.
Here is where you can inspect the request.

Very important to know, you must make a copy of the message because reading the original message changes its State from 'created' to 'copied' and downstream processing won't work. Do this by creating a buffered copy.
NOTE: This applies mostly to getting the message body from a POST request.

public object AfterReceiveRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel, System.ServiceModel.InstanceContext instanceContext)
{
    Console.WriteLine("Inside the ApplyClientBehavior");

    // Create a buffered copy of the request.
    // You can then use the internal copy to work with.
    MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue);
    request = buffer.CreateMessage();
    Message internalCopy = buffer.CreateMessage();
    buffer.Close();

    // Check the message state easily
    Console.WriteLine("State of message: " + internalCopy.State);

    Object correlationState = new object();
    return correlationState;
}

WCF Service with IDispatchMessageInspector

If you want to do any pre or post inspection of a web service such as scheme validation, you can use the IDispatchMessageInspector.

This example is based on the Simple Service example. I modified the Simple Service example and added the IDispatchMessageInspector.

The IDispatchMessageInspector gives you access to 2 events.
- AfterReceiveRequest() fires before you enter the web service method:
object AfterReceiveRequest(ref Message request, IClientChannel channel, InstanceContext instanceContext) { return new Object; }
- BeforeSendReply() fires after you leave the web service method:
void BeforeSendReply(ref Message reply, object correlationState) { }

The object returned from the first method is the 'correlationSate' object of the 2nd method. If your custom validation fails in the first, you can return a 'correlationState' object that the 2nd method will receive automatically. This allows you to return 'Bad Request' or something like that.

There is nothing unusual about the Interface for the service as you can see in ITestService.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;

using System.ServiceModel.Web;

namespace WCFServiceWithScheme
{
    // NOTE: If you change the interface name "ITestService" here, you must also update the reference to "ITestService" in Web.config.

    [ServiceContract]
    public interface ITestService
    {
        [OperationContract]
        [WebGet(UriTemplate = "SchemeTest?name={name}")]
        string SchemeTest(string name);
    }
}

There is also nothing unusual about the class that inherits from the interface. TestService.svc.cs:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.ServiceModel;
using System.Text;

namespace WCFServiceWithScheme
{
    public class TestService : ITestService
    {
        public string SchemeTest(string name)
        {
            return "The name is " + name;
        }
    }
}

The differences begin to show in the Web.config.
You will see the 'behaviorExtensions' tag and the additional addition to the 'endpointBehaviors'.
The name for the 'behaviorExtensions' is the new behavior in the 'endpointBehavior'.
The behaviorExtensions' TYPE is the name of the BehaviorExtensionElement class followed by the namespace.

The system.serviceModel in the Web.confi:

  <system.serviceModel>

    <!-- Required for IDispatchMessageInspector -->
    <extensions>
      <behaviorExtensions>
        <add name="restHttpBehavior" type="WCFServiceWithScheme.MyBehaviorExtensionElement, WCFServiceWithScheme, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null"/>
      </behaviorExtensions>
    </extensions>

    <bindings>
      <!-- Minimum for WebHttp -->
      <webHttpBinding>
        <binding name="WCFServiceWithScheme.MyDefaultBinding"/>
      </webHttpBinding>
    </bindings>

    <behaviors>

      <!-- serviceBehaviors -->
      <serviceBehaviors>
        <behavior name="WCFServiceWithScheme.MyServiceBehavior">
          <serviceMetadata httpGetEnabled="true" />
          <serviceDebug includeExceptionDetailInFaults="false" />
        </behavior>
      </serviceBehaviors>

      <!-- endpointBehaviors -->
      <endpointBehaviors>
        <behavior name="WCFServiceWithScheme.MyWebBehavior">
          <webHttp/>
          <restHttpBehavior/>
        </behavior>
      </endpointBehaviors>

    </behaviors>

    <services>

      <!-- Minimum for WebHttp -->
      <service behaviorConfiguration="WCFServiceWithScheme.MyServiceBehavior" name="WCFServiceWithScheme.TestService">

        <!-- Minimum for WebHttp -->
        <endpoint address="web" behaviorConfiguration="WCFServiceWithScheme.MyWebBehavior" binding="webHttpBinding" contract="WCFServiceWithScheme.ITestService" bindingConfiguration="WCFServiceWithScheme.MyDefaultBinding">
          <identity>
            <dns value="localhost"/>
          </identity>
        </endpoint>

      </service>

    </services>
  </system.serviceModel>

There are 2 new classes that you must create:
* A MessageInspector class that inherits from IDispatchMessageInspector
* A BehaviorExtensionElement class that inherits from BehaviorExtensionElement and IEndpointBehavior.

The MessageInspector class contains the AfterReceiveRequest and BeforeSendReply methods.
Place break points in these methods and you can see the order in which they are fired.

The MyMessageInspector.cs class:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.ServiceModel.Dispatcher;

namespace WCFServiceWithScheme
{
    public class MyMessageInspector : IDispatchMessageInspector
    {

        #region IDispatchMessageInspector Members

        public object AfterReceiveRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel, System.ServiceModel.InstanceContext instanceContext)
        {
            Console.WriteLine("Inside the ApplyClientBehavior");
            // Good idea to return error class stuff to let you know if anything happened in here
            Object correlationState = new object();
            return correlationState;
        }

        public void BeforeSendReply(ref System.ServiceModel.Channels.Message reply, object correlationState)
        {
            // !!!!!!!!! correlationState comes from the AfterReceiveRequest method !!!!!!!!!!!!!
            // If the AfterReceiveRequest method determines it is a bad request, this is where you return, 'Bad Request'
            Console.WriteLine("Inside the ApplyClientBehavior");
        }

        #endregion
    }
}

The BehaviorExtensionElement class contains several methods. The most important one is 'ApplyDispatchBehavior(). This is where you add your message inspector.

The Validate() is fired only during initialization of the service and before ApplyDispatchBehavior().
To test this when running locally, do an IISreset, place a break point in the Validate() method and the other methods, and hit F5 to start debugging.

MyBehaviorExtensionElement.cs

using System;
using System.ServiceModel.Configuration;
using System.ServiceModel.Description;

namespace WCFServiceWithScheme
{
    public class MyBehaviorExtensionElement : BehaviorExtensionElement, IEndpointBehavior
    {
        #region BehaviorExtensionElement
        public override Type BehaviorType
        {
            get { return typeof(MyBehaviorExtensionElement); }
        }

        protected override object CreateBehavior()
        {
            return new MyBehaviorExtensionElement();
        }
        #endregion

        #region IEndpointBehavior Members

        public void AddBindingParameters(ServiceEndpoint endpoint, System.ServiceModel.Channels.BindingParameterCollection bindingParameters)
        {
            Console.WriteLine("Inside the AddBindingParameters");
        }

        public void ApplyClientBehavior(ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.ClientRuntime clientRuntime)
        {
            Console.WriteLine("Inside the ApplyClientBehavior");
        }

        public void ApplyDispatchBehavior(ServiceEndpoint endpoint, System.ServiceModel.Dispatcher.EndpointDispatcher endpointDispatcher)
        {
            Console.WriteLine("Adding custom message inspector...");
            endpointDispatcher.DispatchRuntime.MessageInspectors.Add(new MyMessageInspector());
        }

        public void Validate(ServiceEndpoint endpoint)
        {
            Console.WriteLine("Inside the Validate");
        }

        #endregion
    }
}

WCF Web Service with Scheme Validation and other tricks

This series of posts will cover the various aspects of creating a WCF web service that will use a scheme to validate.

NOTE: This is different than the Secure WCF REST webservice I posted earlier. The previous one uses the WCF REST Starter Kit and has a very simple Web.config.

This series covers:

• Creating a Simple Service based on REST
• Expand the simple service with IDispatchMessageInspector
• Read the GET request parameters in the AfterReceiveRequest() method
• Add a POST method to the service
• How and why you should use 'CreateBufferedCopy' to clone the request
• Read the message body in a POST request
• Loading and using the scheme
• Dynamically expanding the UriTemplate on a Get request
• How to optionally embed the XSD file in the assembly