NullPointerExceptional

A blog for .NET hackers

Providing Additional Query Parameter Types to Wcf Services

| Comments

By default a WCF Service uses the QueryStringConverter to convert query parameter into typed objects. To the according MSDN Documentation (see link above) we cann see, that it supports by default following parameter/object types:

  • Byte
  • SByte
  • Int16
  • Int32
  • Int64
  • UInt16
  • UInt32
  • UInt64
  • Single
  • Double
  • Char
  • Decimal
  • Boolean
  • String
  • DateTime
  • TimeSpan
  • Guid
  • Byte array
  • Uri
  • Object
  • DateTimeOffset
  • Enums
  • Types that have a TypeConverterAttribute that can convert the type to and from a string representation

Hell, these are really lot of types which can be converted - but what if we like to have additional? Let’s guess we like to have Nullable types like DateTime? to make some sort of optional parameter. As the Nullable type is a build in framework type we do not have a chance to decorate it with a TypeConverterAttribute.aspx).

Writing our own QueryStringConverter to the rescue… The task is really simple - derive from QueryStringConverter, override 3 functions and fill in some rules:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

public sealed class ArchiveServiceQueryStringConverter
    : QueryStringConverter
{
    public override bool CanConvert(Type type)
    {
        if (typeof(DateTime?).Equals(type))
        {
            return true;
        }

        return base.CanConvert(type);
    }

    public override object ConvertStringToValue(string parameter, Type parameterType)
    {
        if (typeof(DateTime?).Equals(parameterType))
        {
            if (!string.IsNullOrWhiteSpace(parameter))
            {
                DateTime dateTime;

                //see: http://msdn.microsoft.com/en-us/library/az4se3k1.aspx#Roundtrip
                if (DateTime.TryParse(parameter, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out dateTime))
                {
                    return dateTime;
                }
            }

            return null;
        }

        return base.ConvertStringToValue(parameter, parameterType);
    }

    public override string ConvertValueToString(object parameter, Type parameterType)
    {
        if (parameterType == typeof(DateTime?))
        {
            DateTime? @object = (DateTime?)parameter;
            string value = string.Empty;

            if (@object.HasValue)
            {
                value = @object.ToString("r");
            }

            return value;
        }

        return base.ConvertValueToString(parameter, parameterType);
    }
}

As you can see this isn’t such a big task. Noticable (and this is why I chose DateTime) is the convention I used to convert DateTime into the RFC1123 pattern format. The client side has to do as well to circumvent any problems in converting from and to DateTime. You can read more about Standard Date and Time Format Strings at the MSDN Documentation.

As we have our very own QueryStringConverter (extending the default) supporting Nullable types now we need to tell our WCF Service to use this instead of the default. Therefore we need 2 additional classes to configure a custom behavior which uses our implementation. Theses two classes are a custom WebHttpBehavior and a custom BehaviorExtensionElement.

1
2
3
4
5
6
7
8

public class ArchiveServiceBehavior
    : WebHttpBehavior
{
    protected override QueryStringConverter GetQueryStringConverter(OperationDescription operationDescription)
    {
        return new ArchiveServiceQueryStringConverter();
    }
}

As you can see the custom behavior wires are implementation of the QueryStringConverter to our service. Next is the extension element to extend the service to use the custom behavoir.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class ArchiveServiceBehaviorExtensionElement
    : BehaviorExtensionElement
{
    protected override object CreateBehavior()
    {
        return new ArchiveServiceBehavior();
    }

    public override Type BehaviorType
    {
        get
        {
            return typeof(ArchiveServiceBehavior);
        }
    }
}

With that done, we finally need to update the service configuration Web.config. Beneath the <system.serviceModel> tag we must configure as following:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<services>
  <service name="ArchiveService">
    <endpoint behaviorConfiguration="ArchiveServiceBehavior" binding="webHttpBinding" bindingConfiguration="ArchiveBinding" contract="ArchiveService" />
  </service>
</services>
<behaviors>
  <endpointBehaviors>
    <behavior name="ArchiveServiceBehavior">
      <archiveServiceBehaviorExtension />
    </behavior>
  </endpointBehaviors>
</behaviors>
<extensions>
  <behaviorExtensions>
    <add name="archiveServiceBehaviorExtension" type="TDSKPro.Archive.Services.ArchiveServiceBehaviorExtensionElement, TDSKPro.Archive.Services" />
  </behaviorExtensions>
</extensions>

There is a great article about Extending WCF with custom behaviors over at MSDN Magazine which covers a lot of other scenarios as well. And at least the MSDN documentation covers the extensibility as well: Configuring and Extending the Runtime with Behaviors

Comments