I have included some documentation on the Usage wiki page.

/

Silverlight is different, that it only has asynchronous network calls and you can’t really imitate sync calls, which makes the use of a RPC a little weird.

I have written a small XML-RPC library for Silverlight. Actually its just a single C# file which users can just drag and drop into their projects. The library is still under development, presently I am hacking together a parser, making sure it works with the most common scenarios.

Here is what the usage of this library looks like. You instantiate a service class, and then instantiate query requests as shown below:

XmlRpcService service
            = new XmlRpcService ("http://betty.userland.com/RPC2");
XmlRpcRequest req
            = new XmlRpcRequest (service, "examples.getStateName",
                     new object [] { 10 });
req.XmlRpcCallCompleteHandler
            += new XmlRpcCallComplete (req_XmlRpcCallCompleteHandler);

req.Execute (null);

Once your call completes or some error occurs, your event handler is invoked (Here I am just assuming that the call succeeded):

void req_XmlRpcCallCompleteHandler (XmlRpcResponse response, object userState) {
    string result = (string)response.TryCast (typeof (string));
    System.Diagnostics.Debug.WriteLine ("Result: " + result);
}

You try to cast the response into a string, if it cannot be casted you get back a null or the default value for value types. TryCast is pretty powerful, you can declare a class and have TryCast map the returned struct (associative array) to that class. E.g. lets say we have this fault class:

public class Fault {
    public int FaultCode;
    public string FaultString;

    public override string  ToString() {
                 return "Fault Code: " + FaultCode.ToString ()
                     + ", Fault String: " + FaultString;
    }
}

You can use TryCast to map a fault response to this class. Note that, the names of the members here actually match with those returned when a fault occurs (see XML-RPC spec), case is not important though. You can use your own classes to map with struct returned as XML-RPC responses, this should be pretty handy. I will include more details when I actually release the library.

So a more fault tolerant event handler would look something like this:

Fault f = (Fault)response.TryCast (typeof (Fault));
if (f != null) {
    Debug.WriteLine ("Fault occured: " + f.ToString ());
    if (f.FaultCode == -1) {
        Debug.WriteLine ("OMG! -1 ERROR!");
    }
}
else {
    string result = (string)response.TryCast (typeof (string));
    Debug.WriteLine ("Result: " + result);
}

I am still working on a few things with this library, I will post it up here as soon as I am done, I promise!

Stay tuned!

/

The other day at work I was trying to use .NET’s Dictionary class to create a hierarchical structure which allows me to do something like this:

torqueInfo[eAvatarGender.male][eJointName.elbow][eJointDirection.extension]
	= new TorqueCurves(eAvatarGender.male, eJointName.elbow, eJointDirection.extension);

torqueInfo has been defined as:

Dictionary<eAvatarGender, Dictionary<eJointName, Dictionary<eJointDirection, TorqueCurves>>> torqueInfo;

Using the dictionary object this way would help me reduce my coding clutter to just 3 look-ups instead of coding a 3 level conditional switch (one of the straightforward ways of doing it).

The problem with this is that unlike C++ std::map objects, if a .NET dictionary doesn’t contain the specified key it throws an exception.

Dictionary<int, string> keyVal = new Dictionary<int, string> ();
keyVal [5] = "Hello";		// exception
keyVal.Add (5, "Hello");	// OK

Filling up such a construct with an Add method could have easily turned into a nightmare. To tackle this problem, I created my own little dictionary class which could handle unknown keys and allow the programmer to easily populate a complex construct like I mentioned above. Here’s what the class looks like:

public class SmarterDictionary<TKey, TValue> where TValue : new ()
{
    Dictionary<TKey, TValue> keyVal = new Dictionary<TKey,TValue> ();

    // access operator is all we need!
    public TValue this[TKey key] {
        get {
            if (!keyVal.ContainsKey(key))
                keyVal.Add(key, new TValue ());

            return keyVal[key];
        }
        set {
            keyVal[key] = value;
        }
    }
}

HTH