Something fundamentally missing in GTK#

I've given this a lot of thought after staying up trying to port
MonoDevelop to Win32 and explaining what I was doing to a friend who
was relatively new to Mono but experienced with C#. He seen me adding
conditional compile arguments similar to this below:

#if !WIN32
using Gnome;
using GnomeSharp
#endif

I tried to explain it, before he interrupted me and said, "Isn't mono
suppose to support running the same .NET exe on all platforms?", I
replied "Yes, and it does, but this library isn't on Windows." He
looked confused so I tried to explain, and while doing so, it hit me.
We are doing something wrong in GTK#. Its something that many of us
used to porting anything to anything else would over look, but in Mono
shouldn't really exist and something that Java seems to prevent in the
first place. Let me explain.

We have the mono runtime and mcs C# compiler. The mono application
being capable of running a .NET application or dll on any of its
supported OSs, by reading the application at a CLI layer, and at the
same time allowing us to run the same compiled application across all
those platforms. The mcs tool allows us to compile .NET compatible
EXEs and DLLs.

Now here is the kicker. When building or running a .NET application it
is required that we have all the assemblies used in the application
when we run or build (unless of course you are loading the assembly 
dynamically and using reflection apis). Even if the library is unused
on a platform, its still required to run or build an application that
might use these libraries in the application for a different platform.
That is why I used conditional compile arguments to build on WIN32.
Libraries that currently fall into that catagory are Gnome#, 
Gnome-vfs#, GtkHTML#, and a few others.

It looked correct at the time but now I think that mindset is wrong.
Using compiler arguments to build for WIN32 works, but in the end it,
it generates 2 different platform specific applications. The only way
to have a single application is using late bound assemblies, which
totally sucks.

Now I'm not advocating that we drop libraries like Gnome# or try to
port them all to all operating systems because that’s just silly. What
I'm proposing is that we modify the gapi tools to support generating
"fake" or "look-alike" code. These would be libraries that do nothing
more then mimic the classes, interfaces, types, enums, etc, but when
you try to use them they ether do nothing or return a
"NotImplimenetedException" or something. This would alow you to use
the library to build with on any platform, but if you call code with
one of those libraries not available on for your platform it throws an
exception. So you could test at runtime if its ok to run a library of
another method for the current platform should be used.

Like, for example, instead of using the following and getting 2
different exes:

#if !WIN32
using Gnome
using GnomeSharp;
#endif
...

you could use something like this:

using Gnome;
using GnomeSharp;
using System;

namespace Test{
  public class TestPortablity(){
    public TestPortablity(){
      if (Gnome.IsReal == True) 
        Gnome.DoWhateverInGnome();
      else 
        DoSomethingForWin32Instead();   
    }
  }
}

and it would work with a single exe on all platforms.