IBlog<Johan> : .NET 3.5

Case Switching on CLR Types

jdanforth — Thu, 19 Mar 2009 08:23:20 GMT

As most .NET developers know, you cannot do case/switch on CLR types and one of the reasons for it was explained pretty well years ago by Peter Hallam on the C# team.

But there are many cases where you would like to iterate through a list of objects if mixed types and do specific things depending on it’s type. For fun I started to try out different ways to do it, some are better than others but they all do the same thing, more or less. I’m also exploring method extensions, method chaining and lambdas and some of the samples almost started to become fluent and DLS like.

Note

Oh, I’m as far from a C# language expert as anyone can be, so there are other ways of doing this I’m sure. The random code below is just me playing around for a simple way of doing case/switching on types that worked in the code I’m currently working on.

Also, if you would like a derived class to do something special, you normally override a method, send in some parameters and let that code whatever it so special. That’s basic OOD, see the Eat() method in the sample code below. But there are cases where you for one reason or other would not like to do this. Enough of that, this is just for fun.

A List of Pets

I was working with a class hierarchy of pets like this:

namespace TypeCase

{

public abstract class Pet

{

public string Name { get; set; }

public abstract void Eat();

public override string ToString()

{

return Name;

}

public Pet Case<T>(Action<T> action) where T : Pet

{

if (this is T)

action.Invoke((T)this);

return this;

}

public class Dog : Pet

{

public override void Eat()

{

Console.WriteLine(Name + " eats cats.");

}

public class Cat : Pet

{

public override void Eat()

{

Console.WriteLine(Name + " eats mice.");

}

We got a Cat and a Dog which are both different types of Pet. They have a Name and they can Eat() which is good enough for testing.

Creating the List

I’m creating a simple typed List like this:

var pets = new List<Pet>

{

new Cat { Name = "Morris"},

new Dog { Name = "Buster"}

};

Now we have something to play with. First do something you often see, especially in .NET 1.x code.

Case Switching on Strings

It’s perfectly fine to switch on strings, so this is quite common:

foreach (var pet in pets)

{

switch (pet.GetType().ToString())

{

case "TypeCase.Cat":

Console.WriteLine("A cat called " + pet);

break;

case "TypeCase.Dog":

Console.WriteLine("A dog called " + pet);

break;

}

I’m not too fond of this, because you may rename Cat or Dog in the future, or change namespace of “TypeCase” to something else, and even though renaming stuff with Resharper is powerful, strings are often missed. It would have been nice to:

                    case typeof(Cat):

But that’s not allowed. The case must be a constant.

If Is

A much safer way is to use if … else if … and instead of using string comparing, check the type with the is statement. It’s also faster to type:

foreach (var pet in pets)

{

if (pet is Cat) Console.WriteLine("A cat called " + pet);

else if (pet is Dog) Console.WriteLine("A dog called " + pet);

}

This code is perfectly fine and I’ve used it many times. But what if I wanted to have a Case-like syntax?

Method Extension on Type

I’m thinking of a syntax like this one:

                pet.GetType().
                    Case(typeof(Cat), () => Console.WriteLine("A cat called " + pet)).
                    Case(typeof(Dog), () => Console.WriteLine("A dog called " + pet));
 

In this case we’re extending the Type type with a Case method, like this:

public static class TypeExt

{

public static Type Case(this Type t, Type what, Action action)

{

if (t == what)

action.Invoke();

return t;

}

The Action parameter encapsulate the anonymous method we’re sending in, containing the stuff we want to do with the pet in question. In the Case() extension method we’re testing to see if we’re given the right Type and Invoke() the anonymous method if so.

Important Note: Without going into details, just make sure you don’t fall into a case of “Access to modified closure” when doing for(each) loops around anonymous methods. To be safe, you have to create a local pet-variable outside of the method:

            foreach (var pet in pets)
            {
                //some code
                var safePet = pet;
                pet.GetType().
                    Case(typeof(Cat), () => Console.WriteLine("A cat called " + safePet)).
                    Case(typeof(Dog), () => Console.WriteLine("A dog called " + safePet));
                //some more code
            }

Better Method Extension on Type

But I’m not happy with this syntax. If feels more cumbersome than the if…is…if…else… syntax, and whenever you see the use of typeof() in code like this, generics can do some work for you. So I’m going for a syntax like this:

pet.GetType().

Case<Cat>(obj => Console.WriteLine("A cat called " + pet)).

Case<Dog>(obj => Console.WriteLine("A dog called " + pet));

This requires a new method extension:

public static class TypeExt

{

public static Type Case<T>(this Type t, Action<Type> action)

{

if (t == typeof(T))

action.Invoke(t);

return t;

}

Looks better, but you still risk getting into the issues with modified closure above and I would like to work on the “obj” parameter as if it was the Pet objekt itself, not the Type. Let’s make it even better:

Even Better Method Extension on Pet

Now I’m going for a syntax that looks like this:

foreach (var pet in pets)

{

pet.

Case<Cat>(c => Console.WriteLine("A cat called " + c)).

Case<Dog>(d => Console.WriteLine("A dog called " + d));

pet.Eat();

}

As you can see, the syntax is cleaner and I can work with the pet object itself as a parameter handled to anonymous method in the lambda statement.

To do this I have to create a method extension which knows about the Pet class:

public static class PetExt

{

public static Pet Case<T>(this Pet pet, Action<T> action) where T : Pet

{

if (pet is T)

action.Invoke((T)pet);

return pet;

}

It’s not a generic Case Switcher on Type, but it feels good to me and is easy to work with. And you don’t have the issue with access to modified closures with this one.

Refined Method Extension on List of Pets

I’m throwing in a final variant here, adding the Case method to the list itself:

            pets.
                Case((Cat c) =>
                        {
                            Console.WriteLine("A cat called " + c);
                            c.Eat();
                        }).
                Case<Dog>(d =>
                        {
                            Console.WriteLine("A dog called " + d);
                            d.Eat();
                        });
 
            pets.
                Case((Cat c) => Console.WriteLine("A cat called " + c)).
                Case<Dog>(d => Console.WriteLine("A dog called " + d));
 

As you can see, there are two ways syntactically to provide the type and the simple extension method for this variant looks like this:

public static class PetListExt

    {
        public static List<Pet> Case<T>(this List<Pet> pets, Action<T> action) where T : Pet
        {
            foreach (var pet in pets)
            {
                if (pet is T)
                    action.Invoke((T)pet);
            }
 
            return pets;
        }
    }

That’s it. I’ve seen a number of more complex ways to do roughly the same, but I’m not trying to create the ultimate Switch/Case framework, just playing around with c# to create something simple that may make the code easier to read (and fun to code).

Bad Request With WCF Service in Cassini On Windows 7 Beta

jdanforth — Sat, 14 Mar 2009 15:29:41 GMT

Trying to run a WCF service in Cassini on your Windows 7 Beta (7000) machine and get this error?

The remote server returned an unexpected response: (400) Bad Request.

Unless you’re running your service with basic http binding or with security specifically set to None in your bindings, you will get this security-related error. This problem was confirmed by Microsoft and will (hopefully) be fixed in next Windows 7 release.

The options you got:

Create and run your own service host with code (I’ve been doing this in my integration tests until I tried Cassini and got the error)
Use IIS (which I’m going to go for)
Self-host it with WcfSvcHost.exe (which I’ve not tried yet)

Note that you need to add quite a few features to get WCF running in IIS running on Windows 7. See my previous post about this.

Richard Fennell had the same problems as well as a few others out there brave enough to try out a beta operating system.

Turn Windows 7 Features On or Off

jdanforth — Sat, 14 Mar 2009 13:35:30 GMT

I’m trying to install/add IIS features to my Windows 7 beta build 7000 laptop. You got pretty fine grained control over these features in Windows 7, and it’s not easy to know what you really need. I need to run WCF services on my machine, so I’m turning most things on, including WCF Activation stuff:

Then I’m adding these things that I think I need for your average ASP.NET application:

Finally I’m adding the management tools, including the IIS 6 compatibility stuff which I’ve been told is needed to play properly with VS2008:

Then restart and make sure you got everything in place.

Integration Testing WCF Services with Unity

jdanforth — Fri, 30 Jan 2009 09:36:25 GMT

I've been blogging a few times now about using Unity with WCF, but how do you integration test your service in an easy way without? The way I (and many others) do integration tests for a WCF service is by setting up my own service host and starting the service from test init:

    [TestClass]
    public class ServiceIntegrationTest
    {
        private static ServiceHost serviceHost;
 
        [ClassInitialize]
        public static void MyClassInitialize(TestContext testContext)
        {
            serviceHost = new ServiceHost(typeof(Service1), new [] { new Uri("http://127.0.0.1:8001/") });
            serviceHost.AddServiceEndpoint(typeof(IService1), new BasicHttpBinding(), "Service1");
            serviceHost.Open();
        }
 
        [ClassCleanup]
        public static void MyClassCleanup()
        {
            serviceHost.Close();
        }
 
        [TestMethod]
        public void Should_get_data()
        {
            var ep = new EndpointAddress("http://127.0.0.1:8001/Service1");
            var proxy = ChannelFactory<IService1>.CreateChannel(new BasicHttpBinding(), ep);
            var data = proxy.GetData(1);
            Assert.IsTrue(data == "You entered: 1", "Got wrong data back, got - '" + data + "'");
        }
    }

By doing it this way I don't have to make sure Cassini is started up before the test or having to deploy the service to a local IIS. There is no need for web.config or app.config files and I don't have to add any service reference. This way of doing integration testing of services is described by many others, and it should work quite well on a TFS build server or similar.

Integration Testing WCF Service with Unity

A few blog posts away I wrote about using Unity with WCF, but how do you integration test a setup like that? Remeber that if you have created your own ServiceHostFactory, you specify the factory to use in the .svc markup using the Factory attribute this:

<%@ ServiceHost Language="C#" Debug="true" Factory="IRM.Patterns.UnityService.UnityServiceHostFactory" Service="WcfService3.Service1" CodeBehind="Service1.svc.cs" %>

The "problem" here is that the factory doesn't have any decent public methods to let you create the service host from a given service type. True, there is a CreateServiceHost method which accepts a string representation of the type, but that means your service host factory has to have a reference to the type in question. The way I went around that small issue is by creating a small "harness" around the factory, with a public method which accepts a Type:

    public class UnityServiceHostFactoryHarness : UnityServiceHostFactory
    {
        public ServiceHost CreateServiceHost(Type serviceType, string baseAddress)
        {
            return CreateServiceHost(serviceType, new[]
                                                      {
                                                          new Uri(baseAddress)
                                                      });
        }
    }

A small change to the test-initialize method makes use of this test-harness:

        [ClassInitialize]
        public static void MyClassInitialize(TestContext testContext)
        {
            var serviceHostFactoryHarness = new UnityServiceHostFactoryHarness();
 
            serviceHost = serviceHostFactoryHarness.CreateServiceHost(typeof(Service1), "http://127.0.0.1:8001/");
            serviceHost.AddServiceEndpoint(typeof(IService1), new BasicHttpBinding(), "Service1");
            serviceHost.Open();
        }

Now we're running service integration tests and we have the Unity container loaded as well. I'm sure there are other, smarter and for me uknown ways of achieving the same, but it works for me :) If you want sample code for the UnityServiceHostFactory, please let me know, but know that my code is based on the this sample.

WCF Client Calling ASMX Service with Soap Headers

jdanforth — Mon, 27 Oct 2008 11:29:31 GMT

Need to send soap headers from WCF (Service Reference) clients to older ASMX services? The ASMX service not handling the header properly? It may have to do with namespaces being set in the soap header XML in a way differently from what the ASMX service is expecting.

So, how do you create and add the same type of headers, with the correct namespace, in a WCF client? For every outgoing call?

First, a simple ASMX service for your pleasure to play with:

[WebService(Namespace = "http://tempuri.org/")]
public class Service1 : WebService
{
    public MyHeader myHeader;
 
    [WebMethod]
    [SoapHeader("myHeader")]
    public string HelloWorld()
    {
        if (myHeader != null)
            return "Got header: " + myHeader.MyFirstValue + " " + myHeader.MyOtherValue;
 
        return "Got no header!!";
    }
}

That's it on the server side. Over to the client side... Well, the header itself can be either a class which implements the MessageHeader class, but I prefer to use a normal class decorated with DataContract attribute. Notice the namespace property which matches the one on the service above:

[DataContract(Namespace = "http://tempuri.org/")]
public class MyHeader
{
    [DataMember]
    public string MyFirstValue { get; set; }
    [DataMember]
    public string MyOtherValue { get; set; }
}

In ASMX clients you normally create a soap extension to add the header to every outgoing call, but here the ASMX soap extension is replaced by a (Client)MessageInspector in WCF, which is added to a client endpoint via a behavior. I'm cramming the whole sample implementation into one class:

public class AddSoapHeaderBehavior : BehaviorExtensionElement, IClientMessageInspector, IEndpointBehavior
{
    #region IClientMessageInspector Members
 
    public void AfterReceiveReply(ref Message reply, object correlationState) { }
 
    public object BeforeSendRequest(ref Message request, IClientChannel channel)
    {
        var myHeader = new MyHeader { MyFirstValue = "Yeeehaaaw!!", MyOtherValue = "Gaaah!" };
        var messageHeader = new MessageHeader<MyHeader>() { Actor = "Anyone", Content = myHeader };
 
        request.Headers.Add(messageHeader.GetUntypedHeader("MyHeader", "http://tempuri.org/"));
        return null;
    }
 
    #endregion
 
    #region IEndpointBehavior Members
 
    public void AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) { }
    public void ApplyClientBehavior(ServiceEndpoint serviceEndpoint, ClientRuntime behavior) { behavior.MessageInspectors.Add(this); }
    public void ApplyDispatchBehavior(ServiceEndpoint serviceEndpoint, EndpointDispatcher endpointDispatcher) { }
    public void Validate(ServiceEndpoint serviceEndpoint) { }
 
    #endregion
 
    #region BehaviorExtensionElement Members
 
    protected override object CreateBehavior() { return new AddSoapHeaderBehavior(); }
    public override Type BehaviorType { get { return GetType(); } }
 
    #endregion
}

The endpointbehavior and behaviorextensionelement member implementations are just boilerplate stuff that should be hidden as default behavior by WCF if you ask me, but you need to type this out.

Finally, the behavior must be loaded in the config (or via code):

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.serviceModel>
    <behaviors>
      <endpointBehaviors>
        <behavior name="MyEndpointBehaviors">
          <ClientSoapHeaderAdderBehavior />
        </behavior>
      </endpointBehaviors>
    </behaviors>
 
    <extensions>
      <behaviorExtensions>
        <add name="ClientSoapHeaderAdderBehavior" 
            type="MyBehavior.AddSoapHeaderBehavior, MyBehavior, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null" />
      </behaviorExtensions>
    </extensions>
 
    <client>
      <endpoint name="Service1Soap" 
                address="http://localhost:4221/Service1.asmx" 
                binding="basicHttpBinding" 
                behaviorConfiguration="MyEndpointBehaviors" 
                contract="ClientProxy.Service1Soap" />
    </client>
  </system.serviceModel>
</configuration>

Hope it helps someone.

LINQ to XML in VB.NET and Using the Right Language for the Job

jdanforth — Wed, 15 Oct 2008 11:17:50 GMT

I'm almost always using C# in my .NET projects, unless I'm doing Office automation where the VB-way of dealing with optional parameters helps out making the code a bit cleaner.

The last week we've been upgrading ASMX-clients to become WCF-clients for a number of old .NET 1.1 and 2.0 projects, and we ended up with a bunch of app.config files with loads and loads of WCF client endpoint sections, each of them pointing at their own binding configuration. To manually clean this up would take hours and hours of tedious work which would probably result in more than a few errors.

So I thought maybe I could do search/replace with a regexp-capable editor... or try out XML Literals in VB.NET. I wanted to remove old behaviors, extensions and bindings, then add my own behaviors and extensions and finally change some attributes on each client endpoint. Doing this with XML Literals and XDocument/XElement in VB.NET was quite straight forward and didn't result in too many lines of code:

Imports System
Imports System.Xml.Linq
Imports System.IO
Imports System.Linq

    Sub FixupConfig(ByVal infile As String, ByVal outfile As String)
        Dim defaultBindingConfigurationXml = <binding name="defaultBindingConfiguration"
                                              maxBufferSize="1065536"
                                              maxBufferPoolSize="524288"
                                              maxReceivedMessageSize="1065536"/>

        Dim behaviorsXml = <behaviors>
                               <endpointBehaviors>
                                   <behavior name="FacadeSoapEndpointBehavior">
                                       <SetMaxFaultSizeBehavior size="100000"/>
                                       <ClientExceptionHandlerBehavior/>
                                   </behavior>
                               </endpointBehaviors>
                           </behaviors>

        Dim extensionsXml = <extensions>
                                <behaviorExtensions>
                                    <add name="SetMaxFaultSizeBehavior" 
type="SomeType.SetMaxFaultSizeBehavior, SomeAssembly, Version=1.0.0.0, 
Culture=neutral, PublicKeyToken=null"/>
                                    <add name="ClientExceptionHandlerBehavior" 
type="SomeType.ClientExceptionHandler, SomeAssembly, Version=1.0.0.0, 
Culture=neutral, PublicKeyToken=null"/>
                                </behaviorExtensions>
                            </extensions>


        Dim xdoc = XDocument.Load(infile)

        xdoc...<system.serviceModel>.<behaviors>.Remove()
        xdoc...<system.serviceModel>.<extensions>.Remove()

        xdoc...<system.serviceModel>.Single().AddFirst(extensionsXml)
        xdoc...<system.serviceModel>.Single().AddFirst(behaviorsXml)

        xdoc...<system.serviceModel>.<bindings>.<basicHttpBinding>.Descendants.Remove()
        xdoc...<system.serviceModel>.<bindings>.<basicHttpBinding>.Single().Add(defaultBindingConfigurationXml)

        Dim elems = xdoc...<client>.<endpoint>
        For Each element In elems
            element.@bindingConfiguration = "defaultBindingConfiguration"
            element.@behaviorConfiguration = "FacadeSoapEndpointBehavior"
        Next

        xdoc.Save(outfile)

    End Sub

I've heard people recommend to use VB.NET when dealing with XML and I agree - use the right language for the job. When doing this - remember to import System.Linq or you'll miss some vital extensions like the .Add() and .Single() methods ;)

ASP.NET MVC Preview 5 Released

jdanforth — Sat, 30 Aug 2008 14:18:42 GMT

Hey, I'm just helping to spread the word! A sampled a few links and quotes that has already been posted to blogosphere for your pleasure and knowledge. :)

Download it here -> http://www.codeplex.com/aspnet/Release/ProjectReleases.aspx?ReleaseId=16775

Phil Haack said:

We didn’t originally plan to have another preview. However, we implemented a few significant chunks of functionality and were dying to get feedback so that we could incorporate it into the product before Beta. It helps that with five or so of these interim releases, we’ve become pretty efficient producing these releases.

We plan to have our next release be our official Beta, which means we’ll have a lot more test passes to produce and run before we release the next one.

Some preview 5 related blog posts:

Brad Wilson wrote about changes to partial rendering and view engine in preview 5.

Maarten Balliauw wrote about easier form validation with preview 5.

Nick Berardi has a list of news and changes and also a few issues he's found and submitted bug reports for:

Derik Whittaker had a few comments regarding sealed classes in preview 5:

It looks like that they removed the sealed keyword from many of the Attributes such as HandleErrorAttribute, AuthorizeAttribute and various other existing Attributes.

However, looks like many of the other attributes (some new, some not) such as AcceptVerbsAttribute, ModelBinderAttribute and NonActionAttribute are still marked as sealed. Guys, please unseal all your stuff. If you have a very, very, very valid reason then fine seal them. But if not, let developers loose and unseal them.

Auto Postback with Javascript in ASP.NET MVC

jdanforth — Thu, 28 Aug 2008 12:20:53 GMT

I've looked this up twice now so I'm posting it to my blog for future reference and as a quick-tip for others. Say you got a web page with a dropdown/select listbox and you want to reload/auto postback the page when the selection changes.

One way to do this without involving a Javascript or Ajax library like jQuery (which probably is a good idea anyway :) is to use the "htmlAttributes" parameter of the Html.DropDownList() helper method and add a "onchange" attribute through an anonymous type. Something like this:

    Select a name: <%=Html.DropDownList("Name", ViewData.Model, 
new { onchange = "doSomeJavascript()" })%>

To submit a form, for example:

    <% using (Html.Form<HomeController>(p => p.DropDown(), 
        FormMethod.Post, new { id = "myform" }))
       {%>
    Select a name: <%=Html.DropDownList("Name", ViewData.Model, 
        new { onchange = "document.getElementById('myform').submit()" })%>
    <%  } %>

The minimal DropDown() method of the HomeController class to support this sample looks like this:

public object DropDown()
{
    var list = new List<string> { "Adam", "Bob", "Charlie" };
    return View(new SelectList(list, Request["Name"] ?? list.First()));
}

As you can see, the htmlAttributes parameter is available on many of the Html-helper methods and I'm using ot to add a name attribute to the HTML form as well.

End Note About Basic Knowledge of Javascript and Html

Heh, ASP.NET MVC sure forces you to dust off that old, basic knowledge of HTML and Javascript that I think every web developer should have but the ASP.NET programming model has made us forgot... One could argue that it's niggy gritty stuff that we shouldn't have to worry about, but for me it feels good to know I'm in full control of the generated HTML and I'm not sending one byte more on the wire than what's needed. Yes, it's possible to have the same control with standard ASP.NET applications and controls, but I've seen experienced developers make mistakes around this more than once. ViewState anyone? :D

Returning Json from RESTful Interface with WCF

jdanforth — Sat, 23 Aug 2008 14:18:00 GMT

Someone commented on an earlier blog post I did on REST, POX/POJO and WCF and the comment read:

How about REST WCF bits from .NET 3.5 SP1? Is it possible now to let the user decide in which format he wants the response (xml or json) like MySpace API for example?

The convention is to use a file like extension at the end of the resource to specify data return type (.xml or .json)

api.myspace.com/.../details.xml

api.myspace.com/.../details.json

UPDATE/EDIT: Turns out I was doing this the hard way as there is support for json serialization right from the ServiceContract which makes this extremely easy. Just make sure to specify the ResponseFormat to be json. In a previous "version" of this blog post, I used the JavaScriptSerializer class, which is... dumb :)

First go take a look at the sample that Kirk Evans had on his blog.

Note that it may be easier to create a RESTful interface with ASP.NET MVC if you're into that tech, but that's another blog post.

So, first I'm modifying the REST interface somewhat, adding support for /details.xml and /details.json URI:

[ServiceContract]
public interface IService
{
    [OperationContract]
    [WebGet(UriTemplate="customers/{id}/details.xml")]
    Customer GetCustomer(string id);

    [OperationContract]
    [WebGet(UriTemplate = "customers/{id}/details.json", 
            ResponseFormat=WebMessageFormat.Json)]
    Customer GetJsonCustomer(string id);
}

As you can see, on the GetJsonCustomer() method, I'm specifying the ResponseFormat to be json. That's it :)

A sample implementation for this interface looks like this:

public Customer GetCustomer(string id)
{
    return new Customer { ID = id, Name = "Demo User" };
}

public Customer GetJsonCustomer(string id)
{
    return GetCustomer(id);

Using Fiddler to simulate client request and see what comes out of our RESTful service, we get this result from the /customers/123/details.xml request:

...and this from the /customers/123/details.json request:

{"ID":"123","Name":"Demo User"}

More on RESTful Service with WCF and POX/POCO

jdanforth — Sat, 09 Aug 2008 13:55:00 GMT

Kirk Eveans wrote a blog post about Creating RESTful Services Using WCF, which gives you a good understanding of how to get started with REST on WCF. In his sample, Kirk has 2 methods in a REST interface:

[ServiceContract]
public interface IService
{
    [OperationContract]
    [WebGet(UriTemplate = "customers/{id}")]
    Customer GetCustomer(string id);

    [OperationContract]
    [WebInvoke(UriTemplate = "customers")]
    Customer PostCustomer(Customer c);
}

The Data Contract for Customer looks like this:

[DataContract(Namespace = "")]
public class Customer
{
    [DataMember]
    public string ID { get; set; }
    [DataMember]
    public string Name { get; set; }
}

Kirk also describes how to use the Fiddler tool to send REST request to the service, which is a wonderful tool for these circumstances.

Now, to get the customer with ID 123, just send a GET request to the url: http://127.0.0.1:8000/customers/123 and the service will return:

<Customer>
  <ID>123</ID>
  <Name>Demo User</Name>
</Customer>

To call the other method, PostCustomer(), send a POST request to http://127.0.0.1/customers with the following request body:

<Customer>
  <ID>123</ID>
  <Name>Demo User</Name>
</Customer>

This returns:

<Customer xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
  <ID>123</ID>
  <Name>Hello, Demo User</Name>
</Customer>

NOTE: Remember that you must add a HTTP header, specifying the content type, or the POST request will fail (Content-Type: application/xml).

Wrong Order of Nodes?

But what if the programmer sends the <Name> node before the <ID> node? Like this:

<Customer>
  <Name>Demo User</Name>
  <ID>123</ID>
</Customer>

The service will then return:

<Customer xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
  <ID i:nil="true"/>
  <Name>Hello, Demo User</Name>
</Customer>

Note that the ID is null! If the ID was declared as an integer in the Data Contract, the response from the service would be:

<Customer xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
  <ID>0</ID>
  <Name>Hello, Demo User</Name>
</Customer>

Note that ID is 0 (zero), which could become a somewhat hard bug to catch. I asked Kirk about this and he confirmed the reason for this behaviour is the way the DataContractSerializer works. If no order is specified in the DataContract, it will (de)serialize in alphabetic order. If this is a problem for you, there is away around it by specifying the XmlSerializerFormat attribute on the REST interface:

[ServiceContract]
public interface IService
{
    [OperationContract]
    [WebGet(UriTemplate = "customers/{id}")]
    [XmlSerializerFormat]
    Customer GetCustomer(string id);

    [OperationContract]
    [WebInvoke(UriTemplate = "customers")]
    [XmlSerializerFormat]
    Customer PostCustomer(Customer c);
}

POCO Support in SP1

One of the new features in .NET 3.5 SP1 is the support for POCOs - the DataContractSerializer supports serializing types that doesn't have the [DataContract] or [Serializable] attributes. Aaron Skonnard has a good post on this. This means you can safely get rid of the attributes on the Customer class:

public class Customer
{
    public string ID { get; set; }
    public string Name { get; set; }
}

Note that the DataContractSerializer is still picky about the XML it gets to be able to deserialize it properly. Again, to get a more "relaxed" REST interface where WCF accepts the Name and ID nodes in any order, use the XmlSerializerFormat. I'm not sure this is what you want, but it's an option.

I had a short mail conversation with Kirk about this, and he raised an interesting question about the lack of a industry accepted standard for describing RESTful services and I think he's right there. The XML-node order wouldn't be a problem at all if I gave the client programmer a schema or a contract which specified exactly how the RESTful interface was to be accessed and in which order the XML-nodes must come. Kirk had a lot to say about this, and I do hope he writes up a blog post about his thoughts ;)

There are ways to send and receive any XML to a RESTful interface with WCF, and I'll write a blog post about that another day.

ThreadPool.QueueUserWorkItem with Anonymous Types

jdanforth — Thu, 03 Jul 2008 09:10:25 GMT

I thought this blog post by Matt Valerio was good, and it gave me a few ideas to use in a current test project. He wrote a helper method to be able to use anonymous types when calling a delegate or lambda in the ThreadPool:

public delegate void WaitCallback<T>(T state);

public static class ThreadPoolHelper
{
    public static bool QueueUserWorkItem<T>(T state, WaitCallback<T> callback)
    {
        return ThreadPool.QueueUserWorkItem(s => callback((T)s), state);
    }
}

And his example code for using this method:

ThreadPoolHelper.QueueUserWorkItem(
    new { Name = "Matt", Age = 26 },
    (data) =>
    {
        string name = data.Name;
        int age = data.Age;
        // Long-running computation
    });

Cute, eh?

ASP.NET MVC Supporting IronRuby and IronPython

jdanforth — Wed, 04 Jun 2008 12:29:42 GMT

I just picked up this answer to a comment on ScottGu's blog:

I believe we will be showing using ASP.NET MVC with IronRuby and IronPython later this week at TechEd. I don't think we've finalized what the tooling support will be - but you will be able to use these as language options with ASP.NET.

It would have been cool to be at TechEd...

A .NET Guy Looking at Some Ruby (Part 2)

jdanforth — Sun, 20 Apr 2008 13:23:23 GMT

This is me continuing scribbling down notes as I go along relearning lost Ruby skills and at the same time comparing the Ruby syntax and way of writing code to .NET. In my previous post I very briefly went through the basics of variables, loops, iterators, conditionals and basic sorting. This post will look at classes, methods, inheritance and how to reuse Ruby code with include (require) statements.

Methods

Method or function declaration in Ruby is simple, perhaps even simpler than how VB does it:

def my_method(name)
puts "Hello " + name.to_s
end

my_method "johan"
my_method("johan")

As you can see, you may call the method with or without parenthesis, to Ruby it doesn’t matter. I’ll have to read some more Ruby code to see if there are any exceptions or aesthetic rules to using parenthesis or not, but it seems that many Rubians use parenthesis when calling functions or methods on objects/classes, but leaving it when calling simple methods like puts and similar:

Oh, and Ruby doesn’t support method overloading! There are ways around this with default method parameters, add-ons to the language and so on, but basically – no method overloading. I’ll show some sample code later on when I get to class initialization.

Classes, Constructors and Properties

Ruby is of course object oriented, and very much so (without going into the “where everything is an object” speech). So, of course you can declare objects with properties and methods on them. Declaring a class is familiar:

class MyClass
end

You instantiate a class using a built in static “new” method on the class:

a_class = MyClass.new

Adding a (instance) method to the class is straight forward:

class MyClass
def hello(name)
puts name
end
end

Static methods, or class methods, are declared by prefixing the method with “self.”, like this:

def self.reverse_upcase(name)
name.reverse.upcase
end

Adding a constructor or initializer to the class is done by declaring an initialize function:

def initialize(name)
@name = name
end

As constructor overloading is not possible, you’ll have to add a default value to the parameter, making it optional in a VB-style of way:

def initialize(name = "Anonymous")
@name = name
end

The @name variable is called an object variable and it is distinguished by the use of the ‘@’ sign. There is no need to declare the object variable in any other way, but to access the object variable (or property or attribute or…) you have to add property accessor code to the class:

def name
@name
end

def name=(name)
@name = name
end

Now, class properties is used so much that there is a so called attribute accessor keyword available for you in Ruby, making things a bit simple to type:

attr_accessor :name

There are also other attribute keywords like attr_reader and attr_writer available for your pleasure.

Inheritance

Last thing to say about the basics around classes in Ruby is how to handle inheritance. The syntax is similar to c#, but instead of a colon (:), use the less than (<) operator. A very simple example of where the class Employee inherits from Person could look like this:

class Person
attr_accessor :name

def initialize(name)
@name = name
end
end

class Employee < Person
attr_accessor :number

def initialize(name, number)
@name = name
@number = number
end

def to_s
@name + " (emp# " + @number + ")"
end

end

e = Employee.new("Johan","123")

puts e
puts e.is_a?(Person)
puts e.is_a?(Employee)

Would print:

Johan (emp# 123)
true
true

Class Reuse

If you want to “use” or “include” Ruby code you’ve already written? Save your code (class) into a MyClass.rb file (as an example) and add a “require” statement to the top of your code where you want to reuse the MyClass class:

require "MyClass"

and classes in the MyClass.rb file will become available for you.

Wrapping Up

I guess that’s enough for now. I think this will be enough to be able to understand some Ruby code if you come across it, unless it contains too many weird class methods like Array#flatten and such J. Then there are a bunch of modules available to Ruby for doing a number of things. I may get into that in a later blog post, I’ll see.

All in all I think Ruby is cool. I’ve used dynamic languages and scripting languages before, but nothing as sleek as Ruby. Ruby is minimal code, fast to type and there’s a flow to the code which makes it quite easy to read.

Next I’ll blog about downloading and building IronRuby and using it to call on .NET libraries, WPF and perhaps Silverlight (which seems to be all the buzz right now). I think I’ll look at exceptions and error handling after that and see if I can get some time to look at Rails again.

A .NET Guy Looking at Some Ruby

jdanforth — Fri, 18 Apr 2008 14:58:58 GMT

I’m thinking it would be nice to relearn the basics of Ruby (which seems to gain more and more popularity) and compare it to some of the dynamic features .NET 3.5 has been blessed with. I’m also interested in where the Microsoft version of the language, IronRuby, is now and how I can use the .NET libraries from it. I installed and looked at Rails some (long) time ago now, but I never got the chance to use it and my minimal Ruby skills have now faded to nil again. So this is me taking it up again, hoping I can use it for something real, perhaps for unit testing or just test driving some .NET code with the help of IronRuby.

What you’re reading is just me scratching down notes as I go along, it’s not an article or so, this is just for me to have something to get back to later on, so bear with me. I will probably write down things that are not right or make wrong assumptions, but I’m happy to get comments if you see something awfully wrong.

Edit: I had to change the section on line continuation, because I was wrong about what I first wrote.

Getting Started

So how do I get started? First I need a Ruby implementation for the platform I’m running on, in my case Windows Vista. On RubyForge there is a Windows installer for Ruby which contains everything you need to get going. It’s available on http://rubyforge.org/projects/rubyinstaller/ and I’m going for it. Later on I’m also going to download and build IronRuby and .NET applications using the Ruby language, but you will still need Ruby installed to build IronRuby. The IronRuby website www.ironruby.net has some notes on all this, but I’ll blog on that later I think.

The installer will give you the Ruby language, runtime and an editor called SciTE. It also includes a samples directory which may come in handy. With Ruby you got several options to create and test small console apps. After the installation completes, just open up a command prompt and type “irb” and you’ll get an interactive Ruby command prompt, which is very handy for both testing and learning. Another option is to go to the Start menu and use “fxri”, which is a graphical interface to the Ruby documentation and also includes an interactive Ruby console. I’ve used both today. Fxri is great when you’re looking at someone else’s Ruby code and you see a command or class you don’t recognize.

The Ruby installer also comes with an electronic version of the book “Programming Ruby - The Pragmatic Programmer's Guide” by Dave Thomas – which I can tell is also a great source for knowledge. I’ve not read it yet, but I’ve used it to look up certain things.

Tutorials

Next I need some getting started articles or such, and there are tons of it on the Internet. You could use the book above, but I’m looking for something which will get me into the dirt quickly.

I found a “Learning Ruby” website by Daniel Carrera which looks promising, and I’m using it to learn the very basics. You’ll find it at http://www.math.umd.edu/~dcarrera/ruby/0.3/index.html and it’s using the “irb” console in its first steps, which works perfect with IronRuby. Just open up a command prompt and type:

irb --simple-prompt

You'll be greeted with a prompt like this…

…and off you go. Just type your code and press enter. There are other great intros to Ruby on the Internet, and this one by Steve Litt looks good, http://www.troubleshooters.com/codecorn/ruby/basictutorial.htm

Variables and Strings

Most tutorials start with numbers, strings and variables. There’s not much to say about Ruby variables – you don’t have to declare them, just initialize the variable with a value and start using it:

i = 1

Exactly what I’m expecting from a dynamic language, and strings are very easy to work with:

name = "Johan"
name = name + " Danforth"
puts name

The string class in Ruby has a number of powerful methods you can use to work with, same as with the string class in .NET, but the Ruby string class has more than 100 methods on it (from counting the methods in fxri). The .NET string class has around 70 methods, but 45 of these are extension methods that are new to .NET 3.5, and I think many of them were inspired by dynamic languages just like Ruby. I have to say though that some of the methods in Ruby do the same things sort of and some methods are quite funny. Like squeeze, chomp, chop and such :) Methods for parsing, encoding, converting and such are also included in the Ruby string class, functionality that may be baked into other libraries in the .NET framework.

Running a Ruby Program File

Running a Ruby program from a file is dead easy. From the console type “ruby myprogram.rb” and press enter. The installer also associates the .rb file extension with the Ruby executable, so it’s possible to just type “myprogram.rb” or click the file from Windows Explorer.

A good editor for your .rb programs seems to be SciTE which also comes with the Ruby installer. Just open up the editor, type the program and press F5 to run it (make sure you have saved it with the .rb file type). The results will be shown in the right pane of the SciTE editor. Nifty.

Type Conversion

What strikes me as odd is that Ruby is a dynamic language, but automatic type conversion is sometimes not as good as I would think, and something as simple as this will give you an error:

sum = 1 + 2
puts "The sum is " + sum

test.rb:2:in `+': can't convert Fixnum into String (TypeError)

So, in a print statement like the above, Ruby won’t convert the number variable into a string like c# or VB does:

Dim sum = 1 + 2
Console.WriteLine("The sum is " & sum)

You’ll have to convert the sum variable to a string like this:

puts "The sum is " + sum.to_s

Aesthetic Code

Ruby seems to be much about the aesthetics of the code you write. Most Ruby tutorials seem to bring up naming of variables, classes and methods in an early state. What is funny is that the casing of a variable matters to the interpreter, because if you uppercase a variable, it’s treated as a constant. You can change the value of a constant, but the runtime will give you a warning:

PI = 3.14
puts PI
PI = 3.14159265
puts PI

test.rb:3: warning: already initialized constant PI
3.14
3.14159265

But what about code statements that are too long? In c# you can make a line break after almost any statement, and it's the same thing in Ruby. I was wrong about this at first, because in Ruby (as in VB) you can put a backslash (underscore in VB) at the end of the line to do break up a line of code:

puts "this is a " + "very " + \
"long statement"

Be careful not to put a space after the backslash, or you’ll get a strange looking error:

test2.rb:1: syntax error, unexpected $undefined
puts "this is a " + "very " + \
^

I’m not fond of the line continuation underscore thing in VB, and I’m thinking the same of the backslash in Ruby, so you won't see me use it.

Loops

Ruby seems to be good at this, and the most common syntax for-loops is easy to read and pretty nice:

i = 1
4.times do
puts "pass " + i.to_s
i += 1
end

Well, this is just like any other for-loop out there, but the syntax is nicer. There are other ways to type the same thing in Ruby but I’ll get back to that later. I know people have tried to come up with a similar syntax using .NET 3.5 method extension and lambda expressions, but I think it’s hard to make it as compact as in Ruby. My 10 minute feeble attempt at making a c# version of the Ruby times-method would probably be an extension method like this:

        public static void times(this int number, Action codeblock)
        {
            while (number-- > 0)
                codeblock();
        }

And I could call it with a one-liner lambda expression like this:

var i = 1;
4.times(() => Console.WriteLine("hi! " + i++));

Or with a delegate (with some richer code inside) like this:

            var i = 1;
            4.times(delegate(){
                Console.WriteLine("pass " + i);
                i += 1;
            });

Not as nice as the Ruby variant, but close :) The System.Action Delegate class in .NET 3.5 is pretty awesome btw, and you got a generic version of it as well if you need to pass arguments on to the delegate.

Of course Ruby has the traditional VB-like “for” statement as well, with a couple of variations. A 1-5 for-loop looks like this:

for x in 1..5
puts x
end

But a 1-4 for-loop looks like this, see the difference?

for x in 1...5
puts x
end

2 periods mean as long as the variable is less than or equal to the “to” value (inclusive), 3 periods mean as long as the variable is less than the “to” value (exclusive). I’m sure this is a common coding mistake, as it’s easy to miss. And as you can see, no braces/brackets like in c#, so I guess VB programmers feel a bit more comfortable with this syntax, but the for-loop statement in Ruby is, I believe, syntax sugar for this statement, which involves braces/brackets but equally valid:

(1...5).each {|i| puts i }

Conditional Statements

Conditional statements, in Ruby are a bit of a mix between VB and c#. Like in c#, “=” assigns values and “==” compares. I like that. For example:

a = 1
if a == 1 then
puts "true"
else
puts "false"
end

Arrays and Lists

Arrays in Ruby have much in common with the same in c# and VB.NET, especially with the new features in .NET 3.5. Ruby is zero based, so you address a specific item in the array with [] , and it’s possible to initialize arrays in a similar way in all languages. In Ruby:

numbers = [ "zero", "one", "two" ]
addresses = [ [ 10, "Kings Rd" ], [ 25, "Queens Rd" ] ]

Initializing a simple string array in c# 3.5 is quite similar:

var numbers = new[] { "zero", "one", "two" };

The “addresses” array can be solved in many different ways in .NET, but I think the c# equivalent would be:

var addresses = new[]
{
new object[] {10, "Kings Rd"},
new object[] {25, "Queens Rd"}
};

As you can see, c# requires a bit more typing. Personally I prefer to create an array of anonymous types in c#, as it is much easier to code against:

var addresses = new[] {
new { Number=10, Street="Kings Rd" },
new { Number=25, Street="Queens Rd" }
};

The VB.NET equivalent of a simple string array and array of anonymous types is something like this I think (I’m not a VB-guy):

        Dim numbers() = {"zero", "one", "two"}
        Dim addresses() = {New With {.Number = 10, .Street = "Kings Rd"}, _
                           New With {.Number = 25, .Street = "Queens Rd"}}

Oh, the number of things you can do with arrays in Ruby, and in a very intuitive way too. Reverse, sort, add, remove and other methods we recognize from -.NET List and List<> types, but like the Ruby string class there’s a number of unusual but powerful methods on Ruby arrays like flatten (sample taken from the docs):

s = [ 1, 2, 3 ]            #=> [1, 2, 3]
t = [ 4, 5, 6, [7, 8] ] #=> [4, 5, 6, [7, 8]]
a = [ s, t, 9, 10 ]       #=> [[1, 2, 3], [4, 5, 6, [7, 8]], 9, 10]
a.flatten                   #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10

If I coded Ruby for 10 years, I’m not sure I would ever use that method :) It flattens an array of variable length arrays into a one-dimensional array recursively. Cool to have this method built into the Ruby language from scratch.

But other than a few methods like this, it feels like you can do about the same things with the .NET lists and arrays. You may have to turn your array into a list or vice versa, so again we’re talking a little bit of more code than Ruby, but not too much.

Iterators

Related to arrays are of course iterators. A common way to iterate through a Ruby array is to use do – end like some of the samples above. But there is a cool way to use a similar syntax, each – do – end and pass the current item of the array into a block of code. This seems to be a common style of coding in Ruby:

friends = ["Melissa", "Jeff", "Ashley", "Rob"]
friends.each do |friend|
     puts "I have a friend called " + friend
   end

   5.times do |i|
     puts "pass " + i.to_s
   end

It’s quite possible to use a similar style of coding in c#, by using a foreach loops, lambda expressions or delegates:

var friends = new[] {"Melissa", "Jeff", "Ashley", "Rob"};

foreach(var friend in friends)
Console.WriteLine("I have a friend called " + friend);

5.times(ii => Console.WriteLine("pass " + ii));

public static void times(this int number, Action<int> block)
{
    int i = 0;
    while (i < number)
    {
        block(i);
        i++;
    }
}

As you can see, I’m using a method extension to create my own times() method, using a lambda expression to pass a block of code to the times() method with the help of the generic Action delegate. It’s a variation of the times() method I used earlier.

Sometimes when the loop just contains one line of code some Ruby coders seem to replace the do – end with curly braces like this:

6.times { |i| puts "pass " + i.to_s }

As I mentioned earlier when I wrote about loops, this is just another way to type it. If the compiler turns the do-end into braces or vice versa I don’t know – it just works.

The “each” keyword in Ruby seems to be pretty powerful and lets you iterate through different sorts of lists in many ways. It is also used to handle hash-tables. A hash-table in Ruby is declared and initialized like this:

fruits = {
"123" => "Apple",
"456" => "Banana",
"789" => "Orange"
}

As you can see, we’re using squiggly/curly braces/brackets instead of squares. Not sure why it is like this and I would have preferred to use squares here to as for arrays, but this apparently is the way… To access a particular value, just address it with the key of course:

puts fruits["123"]

And iterating through the table with the each – do – end syntax is starting to feel natural now:

fruits.each do |key, value|
puts key + " => " + value
end

Of course you don’t need to use the names “key” and “value”.

It’s quite similar to the way most other languages handle hash-tables. Hash-table declaration and initialization in c# is quite similar thanks to the new language features in c# 3.5:

var h = new Hashtable {
           {"123", "Apple"},
           {"456","Banana"},
           {"789","Orange"}};

Sorting Your Own Way

In c# lists and arrays there are ways to do your own custom sorting, but in Ruby it’s done in a different way. You write your own sorting in-line in a sort – do – end loop like this for example:

friends = [
    [ "Johan", "Danforth" ],
    [ "Eric", "Quist"],
    [ "Björn", "Poppe" ]
]

friends = friends.sort do |a,b|
a[1] <=> b[1] # compare last names
end

Nice thing here is that is seems to be quite simple to do custom sorting of arrays with complex objects in them. The <=> operator is something which is built into Ruby because sorting and comparing is so often done. Basically a <=> b,

- returns -1 if a is less than b

- returns 0 if a is equal to b

- returns 1 if a is greater than b

The operator is able to work with strings and numbers.

That’s Enough for Now

I think this is enough for now. I’ll post a follow up about methods, classes, inheritance and such later on.

ASP.NET MVC Framework (Part 1) - ScottGu's Blog

jdanforth — Wed, 14 Nov 2007 13:56:54 GMT

I think Scott Guthrie himself just did a better job than me to describe that basics of the ASP.NET MVC Framework on his blog :)

Since then I've been answering a lot of questions from people eager to learn more about it. Given the level of interest I thought it might make sense to put together a few blog posts that describe how to use it in more detail. This first post is one of several I'll be doing in the weeks ahead.

ASP.NET MVC Framework (Part 1) - ScottGu's Blog

Go read it already, it got loads of nice pictures to help get an understanding of it all, including the folder structure which is used as a convention. Somewhat influenced by Ruby on Rails I would say ;)

Considering what I've seen so far of MCV Framework, together with LINQ for SQL and the test framework it reminds me a lot of RoR, but perhaps not as much "convention over configuration" though.