Randall Bits

Quite often in code I have this.

var groups = data.GetGroups();
if(groups != null) {
// work some magic
}

Yesterday I realized I could made the code a little cleaner, by using the null coalescing operator.

var groups = data.GetGroups();
groups = groups ?? new List<Group>();
// work some magic

This may not be useful in all cases, but is helpful when you don’t care if the return value is null, and a null will break your code.  And it is definitely better than not checking at all :)

My environment is Windows 7 with Visual Studio 2010 RTM.  I’m using IIS as my development web server instead of Casini.

If you get an error like “unable to start debugging on the web server” when trying start your site using F5, make sure DOTNET 4 is registered with IIS.

%windir%\Microsoft.NET\4.0.x\aspnet_regiis -i

I had this problem, because I installed Visual Studio 2010 before IIS.

Next if you just get 404 errors or blank pages when trying to navigate through your site, make sure the following settings in the IIS setup under “Turn Windows features on or off” are selected:

Internet Information Services -> World Wide Web Services -> Common HTTP Features -> HTTP Errors

Internet Information Services -> World Wide Web Services -> Common HTTP Features -> HTTP Redirection

Internet Information Services -> World Wide Web Services -> Common HTTP Features -> Static Content

This HTTP Redirection and Static Content are especially important.  ASP.NET MVC 2 won’t work at all without HTTP Redirection and when selecting ASP.NET under Application Development Features Static Content isn’t enabled by default.

Anyway I hope this helps somebody.

UPDATE: Make sure you also have the Application Pool set to DefaultAppPool.

I’ve been working with WPF and by extension MVVM over the last month or two, and to be honest it has been no less than painful.  What used to be simple is now hard, although many things are now possible that perhaps were not before without more effort.  That being said this post mainly about MVVM and how it appears to be more like a fresh new version of code behind.  The basis for my conclusion is that the ViewModel although it allows for “unit testing” ui code, it does not facilitate code reuse.  I personally am I big proponent of unit testing, but that doesn’t necessarily mean others feel the same.  Therefore I cannot judge the merit of MVVM solely based on testability, although in many cases that can be a good measure.  My main issue with MVVM is in the area of code reuse.

Let’s say I have a UI defined for executing a calculation:

:UI
     :Input<TextBox>
     :Result1<TextBox>
     :Result2<TextBox>
     :Calc<Button>

If I were you use MVVM I would need a ViewModel defined like so:

:ViewModel
     :Input<string>
     :Result1<string>
     :Result2<string>
     :Calc()
          :Perform a complex 20 line calculation
          :Set Result1 = calculated result1
          :Set Result2 = calculated result2

Notice the Calc method is pretty complex and to update the view I just need to set Result1 and Result2 equal to my calculated result1 and result2 and all will update nicely.  But let’s say I would like to use that complex 20 line Calc function somewhere else, say in a web app, or in a silverlight app.  It would make sense to me to create an object like so:

:Calculator
     :Input<string>
     :Result1<string>
     :Result2<string>
     :Calc()
          :Perform a complex 20 line calculation
          :Set Result1 = calculated result1
          :Set Result2 = calculated result2

Then the ViewModel would be refactored to this.

:ViewModel
     :Input<string>
          :set()
               :calculator.Input = value
          :get()
              :return calculator.Input
     :Result1<string>
          :get()
              :return calculator.Result1
     :Result2<string>
          :get()
              :return calculator.Result2
     :Calc()
          :calculator.Calc()

Ok so that isn’t so bad, but here is the problem.  Calling calculator.Calc() updates the internal state of the Calculator object.  Part of that change involves updating calculator.Result1 and calculator.Result2, so that the internal state can be read from the object and reflected in the UI.  The problem is how does the ViewModel know that calculator.Result1 and calculator.Result2 have been updated?  There is no way to hook the ViewModel’s Result1 and Result2 to the calculator.Result1 and calculator.Result2.  As far as I can tell the general MVVM implementation doesn’t account for this scenario and would need to be handled using some sort of eventing or other implementation between the Model and the ViewModel.  It is the complexity introduced by this disconnect that leads me to conclude that the ViewModel is just another business logic silo, much like code behind of old in both WebForms and WinForms.  Yes you can now unit test your code behind, but it is code behind nonetheless.

UPDATE1: Similar Post The MVVM Pattern Is Highly Overrated

Just thought I would shared a link to site I thought was really cool.  It allows you to download Visual Studio themes as well as easily create one using a really cool editor.

Check it out.

http://studiostyles.info

Also here is a link to my current Visual Studio 2008 theme if you would like to check it out.

There is an interesting problem I solved today that I thought I might share.  The basic idea can be solved by figuring out how to solve the following problem.

Consider this JavaScript
funcs = []
for(var i=0;i<10;i++)
       funcs[i] = function() { alert(i); }
funcs[4]();

This will alert "10".  Can you change it to alert "4"?  The key to solving this problem is being able to create a function that stores i and then will evaluate the alert later.

Also
funcs[0] alerts "0"
funcs[1] alerts "1"
…
funcs[9] alerts "9"

Get the idea?  Good luck!

As part of the project I’m currently working on I had the need to get all the values out of a dictionary without the benefit of typing, so I had to use reflection.  Here is the best was I’ve been able to come up with and hopefully it is useful to others.

So I’ve decided that I don’t like the two general ways of creating objects in JavaScript so I’ve decided to create my own.  This one is partially inspired by ruby :)

I am using the object literal notation to create the object.  Generally this notation works well until you want multiple instances of the object you are creating.  This is why I have added the new method.  This new method acts as a constructor and will return a function.  This function creates a closure and so all the properties (one,two) and methods (talk) will be unqiue to each “instance”.

So usage would be like this:

world = Hello.new(‘my’,’world’);
universe = Hello.new(‘my’,’universe’);

alert(world.b); // “world”
alert(world.talk()); // “hello: my world”
alert(universe.b); // “universe”
alert(universe.talk()); // “hello: my universe”

As you can see each “instance” is unique.  What makes this instance unique is that you are actually not dealing with the Hello object directly, but with the new function on the hello object.  It is important to place everything inside the new function so that all the variables and functions will be unqiue to each instance.

Good luck!

I have yet to find a simple clear example of using multiple files when embedding IronPython or IronRuby in Silverlight, so I decided to share an example I have been working on.

NOTE: During testing have found this does not work with 0.91 or 0.92 of the DLR.  I guess there is a bug with imports and it should be fixed any day now.  Go here and click all releases to get 0.90 of the IronRuby and IronPython dlls.

Here is the code in my MainPage.xaml.cs:

    public delegate string pyFunc(string s);

    public delegate IronRuby.Builtins.MutableString rbFunc(string s);

    public partial class MainPage : UserControl

    {

        public MainPage()

        {

            InitializeComponent();

            pythonblock.Text = DoPython();

            rubyblock.Text = DoRuby();

        }

        private string DoPython()

        {

            var setup = Python.CreateRuntimeSetup(null);

            setup.HostType = typeof(BrowserScriptHost);

            var runtime = new ScriptRuntime(setup);

            var engine = Python.GetEngine(runtime);

            var scope = engine.CreateScope();

            var mscope = engine.CreateScope();

            var module = engine.CreateScriptSourceFromFile("module1.py");

            module.Execute(mscope);

            runtime.Globals.SetVariable("module1", mscope);

            var source = engine.CreateScriptSourceFromFile("main.py");

            source.Execute(scope);

            var func = scope.GetVariable<pyFunc>("hello");

            return func("world");

        }

        private string DoRuby()

        {

            var setup = new ScriptRuntimeSetup();

            setup.HostType = typeof(BrowserScriptHost);

            setup.AddRubySetup();

            var runtime = new ScriptRuntime(setup);

            var engine = Ruby.GetEngine(runtime);

            var scope = engine.CreateScope();

            var mscope = engine.CreateScope();

            var module = engine.CreateScriptSourceFromFile("module1.rb");

            module.Execute(mscope);

            runtime.Globals.SetVariable("module1", mscope);

            var source = engine.CreateScriptSourceFromFile("main.rb");

            source.Execute(scope);

            var func = scope.GetVariable<rbFunc>("hello");

            return func("world");

        }

    }

Here are the source files:

main.py:

import module1

def hello(s):

    return module1.f1('python hello ' + s)

module1.py:

def f1(s):

    return 'python f1: ' + s

main.rb:

require "module1"

def hello(s)

    f1('ruby hello ' + s)

end

module1.rb:

def f1(s)

    'ruby f1: ' + s

end

I hope this is helpful and if anyone has any suggestions for improvement please let me know.