After struggling around for some time now and having several posts of installation failures (in the comments or at StackOverflow) I picked up the idea of Timur and managed to get the project template for NUnit and ASP.NET MVC 3 put together into a Visual Studio Extension.

The benefit is, that there is no installation which does registry changes but delegates the merge process of needed registry settings to Visual Studio. This is done via a package-definition file added to the extension. If you want to dig deeper into that I can recommend following to read:

1. All Your RegKeys Are Belong To Us
2. Pkgdef and the Experimental Instance in VS 2010

Both articles describe the starting process of Visual Studio and the registry merging well.

At current state the extension is only available for Visual Studio 2010 Professional and higher editions. This is only while I am not aware of the fact if it is possible for lower editions to run extension. Maybe I will research about that later and eventually open the extension for all possible editions.

You can now find the extension under following download-link: ASP.NET MVC NUnit or via Extension Manager in Visual Studio.

Functionality is the same as before - ok there is no much to improve or change ;-)

This is just a quick one…

As I updated the test-project shipped with ASP.NET MVC 3 some days ago to fit with NUnit I thought it’s time to do so as well with xUnit.net (and later maybe with MbUnit - so that all big 4 testing-frameworks could be used).

You can download the stuff right here or as usual in the download area. Installation is as simple it could be - just unzip and double click the install.bat. The package is both x86 and x64 aware as the installer checks your system and figures out what registry entries to be done.

If there are any problems let me know - I’ll try to fix ‘em.

[Sidenote:] I am aware about the fact that there is an xunit.installer.exe bundled with xUnit.net ;-) which will install templates for ASP.NET MVC 1, 2 and / or 3. These templates provided in my copy are 1:1 taken from the MSTest which are build-in. The installer provided templates differ. (just to clarify)

As I read about automated error reporting by Laila Lotfi’s article over at Red Gate’s Simple Talk community site, I first thought yeah nice that’s what we need in good software. But on a second thought I considered that it was not going far enough.

Truly having automated error reporting is quite well but having hundreds or thousands of error’s (depending on the amount of sold licenses) depending on same issues is not what I’d like to see and sorting duplicates out is like a job for someone who killes mom and dad. For a second reason much of a developers live and development process is guided by ticket system ((You can find some good comparison regarding issue-tracking systems at wikipedia.org.)). So why not integrated automated error reporting into a consolidating service (which does that ugly sort and compare job) and let it publish new issues to a ticket system?

Might not be the best solution in town but sounds even better than nothing - right? Next up here is a small image showing up how it should be done:

1. So our application reports its unhandled exceptions to the consolidation service (named AER service) which stores the exception report in it’s storage. I find it reasonable to store all reported exceptions in a storage (even for those issues which are already reported) because it gives the developer even more scenarios (assuming the exception report contains detailed informations about environment and current stack…) under which circumstances this error appears.
2. After storing the report it crawls the bugtracker to find a similar issue, if it doesn’t it creates a new entry containing necessary informations and even a sort of link to the reports in the storage so that the responsible developer can find additional infos for the exception.

That said I will try to post a little series about reaching this end-scenario. The tools and libraries I choose to achieve this goal are based on the facts that I owned licenses of them already - but I guess it is even achievable with others.

So what I have is:

1. Red Gate’s SmartAssembly 5: this tool does already a nifty job for automated error reporting. To be honest you will need the PRO version to reach the finish line in this scenario, while that is the version which gives you access to the SDK and a self-hosted custom web-service. ((You can read about its detailed features and why I chose to give it a shot for automated error reporting here and here))
2. JetBrain’s YouTrack - as they say the fastest issue and bug-tracker. This isn’t much the reason why ;-) - I have it so I use it - it has a REST API so I think I can even link it into the set goal.

What do I need (which seems to be not so much at least):

1. an interface to YouTrack - REST based!
2. a synchronisation job which is called after an exception gets reported - to decide if an issue has to be created and does so via the mentioned REST based client

First I thought:

This seems to be very pleasant and causing not very much work

But the problems I were facing are:

1. There is already a C# YouTrack REST client - named YouTrackSharp written by the famous @ hhariri - the JetBrains guru itself. Sadly it is an implementation which uses the JSON API of YouTrack - which is really really broken - so I did not get managed to hook some attachment support in it. Maybe another reason is that I do not know very much about JSONFx which is used in there, too. And the lack of documentation doesn’t made it easier for me. So I decided to build up my own REST client for YouTrack - based on the XML REST API using RestSharp which I know pretty well. I named it RestTrack. It isn’t 100% finished yet - but it does all I need to create issues, search them, create attachments and so on… I will release the source in near future. As said it isn’t such as good as YouTrackSharp (which uses .NET 4 dynamics already) - it’s more the old-school way using XML-Attributes but it fits my needs :-)
2. My second problem was/is that the SmartAssembly documentation in this case is a bit - let’s say - lean. So I have to trouble the support really a lot. But they are as always good and gave me lot of stuff at the hand - thanks for that!

Covering the basics here you can expect in the next post some code stuff about RestTrack and how it can be used to search, create and attach files to issues.

Stay tuned… and as always: suggestions are pretty well appreciated!

Update [2011-04-03]:
Time for another update: The extension is is of today hosted on Visual Studio Gallery. Read ASP.NET MVC NUnit test template on Visual Studio Gallery for further information.

Update [2011-01-22]:
Meanwhile ASP.NET MVC 3 RTM has arrived - this template is still good to go even for RTM version. As you can see in the comments I initially forgotten to explicitly mention that the originally template was x64 only. As an result I tried to change the .bat file accordingly to handle x86 platforms as well. So when you download the newly packed template this should determine if your system is x86 or x64 and call the proper files for installing the template correctly.

The first deployed template also contained a reference to a specific NUnit version even when version-specific switch for Visual Studio was set to false I now removed this version-reference.

As most of you may have read in the meanwhile on December, 10. ASP.NET MVC 3 RC 2 was released. (you can read the announcements over @ ScottGu’s Blog or you’ve been haacked)

What ships with that release again is the possibility to create new test-projects (according to a new created projects), from the build-in project templates, which does use the Microsoft unit-testing framework (in the wizard called Visual Studio Unit Test). This isn’t anything new!

Based on Piotr’s MVC 2 test-project template I updated it (based on the shipped MvcWebApplicationTestProjectTemplatev3.0.cs.zip) to be compatible with ASP.NET MVC 3 (RC2) and changed the notation to Assert.That(…, Is-constraint) - which I prefer while using NUnit.

So the vstemplate looks like this now:

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

<VSTemplate Version="3.0.0" xmlns="http://schemas.microsoft.com/developer/vstemplate/2005" Type="Project">
    <TemplateData>
        <Name Package="{E0915DB0-C6DC-4BF6-AEBF-9D72308FDB81}"/>
        <Description Package="{E0915DB0-C6DC-4BF6-AEBF-9D72308FDB81}"/>
        <Icon Package="{52CBD135-1F97-2580-011F-C7CD052E44DE}" ID="531"/>
        <ProjectType>CSharp</ProjectType>
        <ProjectSubType>
        </ProjectSubType>
        <SortOrder>1000</SortOrder>
        <CreateNewFolder>true</CreateNewFolder>
        <DefaultName>MvcApplicationTest</DefaultName>
        <ProvideDefaultName>true</ProvideDefaultName>
        <LocationField>Enabled</LocationField>
        <PromptForSaveOnCreation>true</PromptForSaveOnCreation>
        <EnableLocationBrowseButton>true</EnableLocationBrowseButton>
        <RequiredFrameworkVersion>4.0</RequiredFrameworkVersion>
        <Hidden>true</Hidden>
        <TemplateID>MvcWebApplicationNUnitTestProjectTemplate.cs.vstemplate.v3</TemplateID>
    </TemplateData>
    <TemplateContent>
        <CustomParameters>
            <CustomParameter Name="$MVCReferences$" Value="System.Web.Mvc.dll"/>
        </CustomParameters>
        <Project File="MvcApplicationTest.csproj" ReplaceParameters="true">
            <ProjectItem ReplaceParameters="true" TargetFileName="App.config">App.config</ProjectItem>
            <Folder Name="Controllers" TargetFolderName="Controllers">
                <ProjectItem ReplaceParameters="true" TargetFileName="HomeControllerTest.cs">HomeControllerTest.cs</ProjectItem>
                <ProjectItem ReplaceParameters="true" TargetFileName="AccountControllerTest.cs">AccountControllerTest.cs</ProjectItem>
            </Folder>
            <Folder Name="Properties" TargetFolderName="Properties">
                <ProjectItem ReplaceParameters="true" TargetFileName="AssemblyInfo.cs">AssemblyInfo.cs</ProjectItem>
            </Folder>
        </Project>
    </TemplateContent>
</VSTemplate>

If you compare it to the old MVC 2 template you will probably notice that the extension wizard is gone. Don’t know why - maybe we should ask @haacked about that…

A sample of the generated NUnit-Tests (as of the HomeController):

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

[TestFixture]
public class HomeControllerTest
{
 [Test]
  public void Index()
  {
      // Arrange 
      HomeController controller = new HomeController();
      // Act 
      ViewResult result = controller.Index() as ViewResult;
      // Assert 
      Assert.That("Welcome to ASP.NET MVC!", Is.EqualTo(result.ViewBag.Message));
  }

 [Test]
  public void About()
  {
      // Arrange 
      HomeController controller = new HomeController();
      // Act 
      ViewResult result = controller.About() as ViewResult;
      // Assert 
      Assert.That(result, Is.Not.Null);
  }
}

To use the new template you still need a registry key referring to the new package. The one I used is only x64 compatible. Remember: The GUID’s of the vstemplate and the registry need to match.

1
2
3
4
5
6

Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\VisualStudio\10.0\MVC3\TestProjectTemplates\NUnit]
"Path"="CSharp\\Test" "Package"="{E0915DB0-C6DC-4BF6-AEBF-9D72308FDB81}"
"Template"="MvcWebApplicationNUnitTestProjectTemplatev3.0.cs.zip"
"TestFrameworkName"="NUnit Test"

Alongside to the updated registry entry I added an install.bat file which does the necessary steps

1. insert registry key
2. copy template archive
3. update Viusal Studio 2010 project template cache

It isn’t much about magic glue in it, just for completeness sake I post the batch-script:

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

@echo off

echo ==== Installing ASP.NET MVC 3 NUnit project template ====

echo Updating registry settings [X64]
regedit /s MvcWebApplicationNUnitTestProjectTemplate.reg

echo Copying MvcWebApplicationNUnitTestProjectTemplatev3.0.cs.zip to Visual Studio 2010 project templates folder
xcopy .\MvcWebApplicationNUnitTestProjectTemplatev3.0.cs.zip "C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\ProjectTemplates\CSharp\Test" /Y /I

echo Updating Visual Studio 2010 project template cache
"C:\Program Files (x86)\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe" /setup

echo ==== Done ====

pause

After executing the install.bat and creating a new ASP.NET MVC 3 application the project template should show up as following:

I packed an archive containing als the stuff (reg key, vstemplate.zip and install.bat). Feel free to download :-)

Happy unit-testing!

In my humble opinion there are two different steps in a validation process (either web-based or n-tier). First the formal/structural correctness, like all required fields are filled or a given credit card number matches its structural requirements etc. Second is the technical/functional correctness, like is this given user name / password combination (which meets its structural requirements as they are filled) even a valid combination in our database.

As differentiating these two steps in a validation process, I think they have to take place in two different locations. Functional correctness does not have to be proven, if a structural correctness isn’t given. Thinking of request - response scenarios why make a request if not all structural requirements are met. As speaking in client and server side - structural validation has to be done on the client-side whereas functional validation on the server-side. Most of you will agree in this points - as this is what the majority did over the last few years.

In web applications client-side validation is mostly done by using javascript - and jQuery is truely the state of art library for doing javascript operations. Therefore I used the jQuery validation plugin to do some checks on a form before posting it to the server for functional checks. As the docs are quite good what is this post all about you will surely ask?!

It’s not just about how to use jQuery validation but also how to extend it with your own validation checks and how to customize the messages thrown if some validations fail.

First of some basics in using jQuery validation to get it work. It’s quite simple (as written in the docs) to wire jQuery validation to your form. By a) auto-wiring the validator to a submit button (the sample is taken from the docs, where your form has id = commentForm):

1
2
3

$(document).ready(function() {
  $("#commentForm").validate();
});

or b) wiring it manually to a whatever you like (as I did it, by wiring the validator to a link):

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

<a href="#" onClick="Calculate(); return false;">Calculate</a>

<script language="JavaScript">
    function Calculate ()
    {
        var quickcheckForm = jQuery("#quickcheck_form");

        quickcheckForm.validate();

        if (quickcheckForm.valid())
        {
            ...
        }
</script>

Next step is to tell the validator the expectations you like to have on your fields. This is as simple as before. Just chain classes together. Each class represents an attribute on your field. So what are the possibilities? Thereare a few build-in classes (following is just an excerpt of the most often used, I guess):

• required
• optional
• min
• max
• email
• url
• date
• dateISO
• number
• digits
• creaditcard
• range

Wiring those attributes to my sample would result to:

1

<label><input class="required digits" type="text" name="stock" id="e13" /></label>

As you can see, I bound the attributes required and digits to my input fields. A different possibility in place of classes is to set rules per javascript. (but I like the class notation a little more, because it’s much more clear to read). Same sample would result into following javascript notation:

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

$("#quickcheck_form").validate({
  rules: {
    e13: {
      required: true,
      digits: true
    }
  },
  messages: {
    e13: {
      required: "Enter your stock amount",
      digits: "Please enter digits only"
    }
  }
});

So these are the basics you need to use the validation plugin. So me requirements were a bit more way off mainstream (I do not really think so, but that’s a different story ;-) ) I needed some decimal validator which accepts only positive digits, 0 to 1 decimal place and up to 2 pre-decimal places.

Luckily jQuery validation offers an addMethod function to extend the common rules (aka attributes or methods):

1
2
3
4
5
6

jQuery.validator.addMethod("decimal1",
    function(value, element) { return this.optional(element) || /^(\d{1,2})$/.test(value) || /^(\d{1,2})(,\d{1})$/.test(value); },
    "e.g.: 5,9")

jQuery.validator.classRuleSettings.decimal1 = {decimal1: true};

So I added a new custom test-method decimal1 (1 = assuming the max count of decimal-places) with two regular expression matching my requirements. Wow - that was easy! I “chained” 3 possible validations together:

1. optional –> maybe it isn’t a required field
2. max 2 pre-decimal places without decimal places
3. max 2 pre-decimal places with max 1 decimal place

The next requirements were to have some custom messages if any validations were broken. jQuery extend to the rescue:

1
2
3
4
5

jQuery.extend(jQuery.validator.messages,
    {
        required: " Pflichtfeld", digits: " Zahlenfeld", decimal1: " Bsp.: 5,9"
    }
);

This is a fine way to “overwrite” the default messages of jQuery validation (nevertheless jQuery validation offers some localization in may different languages). So these are some really good tools to build up client-side form validation to have some useful user-interaction on your web-ui and preventing unnecessary server-request.

Finally I like to mention another two articles dealing with client-side validation:

1. Form validation with JavaScript
2. About client-side form validation and frameworks

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

Some time ago I posted about truncating a database. At that point (I guess my SQLServer skills weren’t as advanced as at nowadays - which doesn’t mean they are quite well now ;-) ) I thought this was a good solution - googling leads often to the same solution.

But getting older and gray in the head I realized there is a much better way to do: sp_MSdependencies one of several undocumented stored procedures of the SQLServer.

The advantage of sp_MSdependecies is, that it retrieves all dependent objects in a hierarchical list (expressed by the osequence). If you fill NULL on the objname parameter it retrieves all objects in the right order. Nice trick! So what I did is to load the data into a temp table and sort it according to its osequence to build the correct order. Remember: Deleting tables with foreign-keys needs to have a different order than deleting data from it.

I use the following snippet from time to time and want to share with you:

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

BEGIN
    DECLARE @schema NVARCHAR(32) = '<your-schema-name-here>'
    DECLARE @table NVARCHAR(128)

    DECLARE @statement NVARCHAR(128)

    DECLARE @dependencies
      TABLE ( oType SMALLINT
            , oobjname SYSNAME
            , oowner NVARCHAR(50)
            , osequence SMALLINT
            )
    -- load dependecnies
    INSERT
      INTO @dependencies
      EXEC [sys].[sp_MSdependencies] @objname = NULL

    -- filter by oType 8 == Table and given schema
    DECLARE TableCursor
     CURSOR FORWARD_ONLY FAST_FORWARD READ_ONLY
        FOR SELECT [TD].[oobjname]
              FROM @dependencies TD
             WHERE [TD].[oType] = 8
               AND [TD].[oowner] = @schema
             ORDER
                BY [TD].[osequence] DESC

    OPEN TableCursor
    FETCH NEXT FROM TableCursor INTO @table

    WHILE @@FETCH_STATUS = 0
    BEGIN
        SET @statement = N'DROP TABLE [' + @schema + '].[' + @table + ']'
        EXEC [sys].[sp_executesql] @statement

        FETCH NEXT FROM TableCursor INTO @table
    END

    CLOSE TableCursor
    DEALLOCATE TableCursor
END

What we actually were trying to achieve is, that we can call a WCF RESTService function doing a PUT action and having multiple (exactly three) input parameter. First goal was having only two input parameter of type URL parameter and the third within the body. (should be like a kind of put that body parameter beneath the entity which is identified by parameter one and two - this is how we do the interpretation of a RESTful Service). From the WCF perspective this isn’t such difficult quest:

1
2
3
4
5
6

[WebInvoke(Method = "PUT", 
        UriTemplate ="CreateArchive/IncidentId/{IncidentId}/IncidentTimestamp/{IncidentTimestamp}", 
        RequestFormat = WebMessageFormat.Json, 
        ResponseFormat = WebMessageFormat.Json)]
[OperationContract]
ItemResult<string> CreateArchive(Guid incidentId, DateTime incidentTimestamp, Dictionary<string, byte[]> archiveContent);

On the other end of the wire is an RestSharp client sitting, which actually made this task as simple as on the WCF side.

1
2
3
4
5
6
7
8
9
10
11
12

RestClient client = new RestClient(baseUrl);

RestRequest request = new RestRequest { Method = Method.PUT,
                                        Resource = "CreateArchive/IncidentId/{IncidentId}/IncidentTimestamp/{IncidentTimestamp}",
                                        RequestFormat = DataFormat.Json
                                      };

request.AddParameter("IncidentId", incidentId, ParameterType.UrlSegment);
request.AddParameter("IncidentTimestamp", incidentTimestamp.ToString("r"), ParameterType.UrlSegment);
request.AddBody(content);

RestResponse<ItemResult<string>> result = client.Execute<ItemResult<string>>(request);

But we figured out some problems resulting from the type we chose for the input parameter. The Dictionary<string, byte[]> instance was always NULL. It took some time to figure out it was always NULL. Reading the MSDN docs carefully shows why: Stand-Alone JSON Serialization contains following paragraph:

Dictionaries are not a way to work directly with JSON. Dictionary<string,object> may not be supported in the same way in WCF as expected from working with other JSON technologies. For example, if “abc” is mapped to “xyz” and “def” is mapped to 42 in a dictionary, the JSON representation is not {“abc”:”xyz”,”def”:42} but is [{“Key”:”abc”,”Value”:”xyz”},{“Key”:”def”,”Value”:42}] instead.

So the cause is that WCF is not compatible to general AJAX/JSON serialization but uses its own Serializer/DeSerializer -> the DataContractJsonSerializer. RestSharp sits on top of the Json.NET library - a general approach to work with JavaScript and JSON formatted data. The incompatibility appears in our case in the Dictionary parameter while the other data types were well serialized and deserialized. The following graphic tries to show the incompatibilities in a more strikingly way.

Fortunately RestSharp offers the ISerializer and IDeserializer interfaces to contribute own implementations of adapter supporting special communication protocols (as the WCF datacontractjsonserializer is in this case). So what wie did is implement our own JsonWcfSerializer:

1
2
3
4
5

public sealed class JsonWcfSerializer
: ISerializer
, IDeserializer
{
}

containing two functions string Serialize(object obj) and T Deserialize(RestResponse response) where T : new() using the datacontractjsonserializer.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

public string Serialize(object obj)
{
   if (null == obj) throw new ArgumentNullException("obj");

   string result;
   DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(obj.GetType());

   using (MemoryStream memoryStream = new MemoryStream())
   {
      dataContractJsonSerializer.WriteObject(memoryStream, obj);
      memoryStream.Seek(0, SeekOrigin.Begin);

      using (StreamReader streamReader = new StreamReader(memoryStream))
      {
         result = streamReader.ReadToEnd();
         streamReader.Close();
      }

      memoryStream.Close();
   }

   return result;
}

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

public T Deserialize<T>(RestResponse response) where T : new()
{
   if (response == null) throw new ArgumentNullException("response");

   DataContractJsonSerializer dataContractJsonSerializer = new DataContractJsonSerializer(typeof(T));
   T result;

   using (MemoryStream memoryStream = new MemoryStream(Encoding.UTF8.GetBytes(response.Content)))
   {
      memoryStream.Seek(0, SeekOrigin.Begin);
      result = (T) dataContractJsonSerializer.ReadObject(memoryStream);
      memoryStream.Close();
   }

   return result;
}

So as you can see in the second graphic the adapter turned from orange to gray and is now fitting the WCF communication protocoll.

At least I like to share some configuration parameters with you - in our case we need to send some byte[] with a length larger than the default 64kb (65536 bytes). Beneath the bindings-section of your system.ServiceModel section in the Web.config you need some additonal entries:

1
2
3
4
5

<webHttpBinding>
   <binding name="ArchiveBinding" maxBufferSize="10485760" transferMode="Buffered" bypassProxyOnLocal="false" closeTimeout="00:01:00" openTimeout="00:01:00" receiveTimeout="00:10:00" sendTimeout="00:01:00" maxReceivedMessageSize="10485760">
      <readerQuotas maxDepth="32" maxStringContentLength="2147483647" maxArrayLength="2147483647" maxBytesPerRead="2147483647" maxNameTableCharCount="2147483647" />
   </binding>
</webHttpBinding>

As you can see it consists of two parts - the binding and the readQuotas. The maxBufferSize (maxReceivedMessageSize - which must be of same value as maxBufferSize) controls the amount of data, which could be received by the service. (in our case we estimate a length not bigger than 10MB). As you can guess a byte[] of 10MB has some extraordinary length. Therefore you need the readQuotas to allow the service a deserialization of an array with such length. We set the quotas to Integer32.MaxValue which is the max value allowed - as we are in a closed private system.

Hope this helps to send dictionaries to and receive them from your Wcf-Service!