I was bored, and it didn’t seem to have been done before, so here’s some Future action in C#.

The Code

using System;
using System.IO;
using System.Reflection;
using System.Threading;
 
public class Future<T> {
        public delegate R FutureDelegate<R>();
        public Future (FutureDelegate<T> del) {
                Del = del;
                Result = del.BeginInvoke(null,null);
        }
        private FutureDelegate<T> Del;
        private IAsyncResult Result;
        private T PValue;
        private bool HasValue = false;
        private T Value {
                get {
                        if (!HasValue) {
                                if (!Result.IsCompleted)
                                        Result.AsyncWaitHandle.WaitOne();
                                PValue = Del.EndInvoke(Result);
                                HasValue = true;
                        }
                        return PValue;
                }
        }
        public static implicit operator T(Future<T> f) {
                return f.Value;
        }
}
 
public static class MainClass {
        //This is purposely wasteful!
        public static ulong Fib(ulong n) {
                if (n > 1) {
                        return Fib(n-1)+Fib(n-2);
                }
                else if (n == 1)
                        return 1;
                else //n == 0
                        return 0;
        }
        //Demo using futures.
        public static void Main(string[] args) {
                Console.WriteLine("First, call synchronously.");
                Console.WriteLine(Fib(40));
                Thread.Sleep(1000);
                Console.WriteLine("Next, call asynchronously.");
                Future<ulong> fib40 = new Future<ulong>(delegate{
                        return Fib(40);
                }); //Begins computing Fib(40) at this point...
                Thread.Sleep(1500);
                Console.WriteLine("Note that we can do other things in the mean time, and that the thread only blocks when we ask for the value.");
                Console.WriteLine(fib40); //Need it now!
                Thread.Sleep(2000);
                Console.WriteLine("We can then ask for the computed value as many times as we like.");
                Console.WriteLine(fib40); //Already computed.
        }
}

Caveats

Most notably, this doesn’t do promise pipelining (and I doubt I could without some compiler magicking), so instead of nesting futures, you’ll want to seperate them out. That is; instead of:

t3 = new Future(delegate{return new Future(delegate{return x.a()}).c(new Future(delegate{return y.b()}))});

…you’ll want to do:

t1 = new Future(delegate{return x.a()});
t2 = new Future(delegate{return y.b()});
t3 = new Future(delegate{return t1.c(t2)});

…although you’d probably want to do this anyway if you don’t want to wander into The LispZone.

First up is DejaVu Sans, which is my default sans-serif font on my system. It is quite plain looking which is possibly a good thing as it doesn’t distract from the task at hand. The ’0′ and ‘O’ characters are different enough, but you may have problems with ‘I’ and ‘l’.

Next I tried Candara, which is a new font that is bundled with Windows Vista. It has a bit of character, but the text figures are a bit distracting, and the punctuation really doesn’t fit in nicely with the rest of the font.

Finally I picked URW Gothic. While this was just a test to see how extreme the fonts could be before they were completely unsuitable for coding, it turned out to work surprisingly well. The large open geometric shapes make for easy reading and the punctuation goes well with the other glyphs. The only problem I could identify is the square brackets looking too much like the rounded ones, but if you can get over that it looks like a very nice font to program with. In fact, I’ve just changed it to be the default in MonoDevelop.

Of course, there are many other sans-serif fonts out there, but I picked these three as representative of several classes of styles. If anyone knows of sans-serif (or even serif!) non-monospace fonts that have been specifically designed for programming, I’d be glad to hear about them.

Promise

First of all I headed over to the Beagle site. It turns out that if you want to do more than handle a specific file-type (not an option in this case because the playlists are stored as .xml) you create not a “Filter” but a “Queryable”. Unfortunately the Queryable HowTo is still being written. Nevermind, I can always ask on the mailing list, and taking a look through the tutorial for Filters shows that the API for that is nice and clean and should be similar for the Queryables.

Next I try to find a reference for the C# DBus bindings. I install the Monodoc documentation for DBus, only to discover everything marked with “Documentation for this section has not yet been entered”—the default message for undocumented functions, classes, and so on. Nevertheless, I find a short tutorial on how to use Python with DBus to control Rhythmbox. The class names and functions seem to have similar titles in C#, so I figure this will map fairly directly.

Finding the DBus reference for Rhythmbox takes a fair bit more effort, trawling through mailing list archives on Google. Eventually I find the DBus APIs hiding in a couple of .xml files in the CVS repositories; org.gnome.Rhythmbox.PlaylistManager looks promising.

Misfortune

Unfortunately, I find a post by a last-exit hacker in which he states (my emphasis):

As I was told DBus C# bindings are unusable I went on about writing DBus# objects the hard way.

What? This can’t be right, I’ve already written a little test program:

using System;
using DBus;

namespace RhythmboxQuery
{
   class MainClass
   {
      public static void Main(string[] args)
      {
         Connection bus = Bus.GetSessionBus();
         try {
            Service rhythmbox = Service.Get(bus,"org.gnome.Rhythmbox");
         } catch (ApplicationException ex) {
            Console.WriteLine("Rhythmbox not started: " + ex);
            return;
         }
         Console.WriteLine("Found Rhythmbox.");
         /*

         Okay, so all I need to do now is to call `getPlaylists` on:
         /org/gnome/Rhythmbox/PlaylistManager

         */
         Console.WriteLine("Uhoh.");
      }
   }
}

Despite my valiant attempts to stave off the past through trivial C# programs, the DBus site confirms the aforementioned revelation:

They are schedualed to be removed from the core but has yet to find a maintainer. [sic]

Epilogue

As it turns out, what I had been planning to do would have been impossible anyway because the Rhythmbox DBus bindings lack a PlayPlaylist function in any of the three interfaces. Also, it seems that DBus under C# only plays nicely with C# objects that you have access to—but this could be just because I couldn’t find a single example of how to call methods on non-C# DBus applications.

Ah well, that Beagle Filter API did seem quite nice anyway, I wonder if there are any filetypes I could parse out there…