Previous predictions: 2008, 2009, 2010.

Since last time I did these predictions, I have moved away from Oslo, the capital of Norway, to a small place called Vennesla. Vennesla is just outside of Kristiansand, in the southern parts of Norway. Here I work for a consulting company called Deepmind, where I work as a senior solutions architect.

“A lot of movie and game predictions for The Tens evolve around misery of all forms: World Wars, famine, terror, death and global disasters from natural disasters, the creation of intelligent machines and whatnot. I predict that very little of the movies and games mentioned above will come true”

Already in the introduction, I was very wrong. There are wars all over the world, and I live in a country that is part of the crimes against humanity. We sent fighter planes and bombed Libya. We have lots of military forces in Afghanistan. While these efforts will come to an end, the people of these areas will never receive an apology from our governments. They will be left to their own, after we have helped destroy their countries. I hope for better times for these people, but when they lack even the most basic human needs, it is going to take a long while before they can reap any benefits from technological developments.

We still have famine in some parts of the world. It’s incredible and unbelievable that this is still happening. It’s something we could have gotten rid of easily, with minimal efforts. Yet, it’s not going to happen. Politicians and world leaders are responsible for holding the poorest down in the mud and keeping them there. There won’t be any real peace in the world, unless people are free from their leaders, including “democratic” countries in the west.

When disasters happens somewhere today, it is on the local news within hours. While the news media reports on more global disasters than ever before, it doesn’t mean that more bad things are happening. We get fed up with the media from time to time, they are a huge source for negative input and can be exhausting for any adult individual, let alone how our kids are bombarded with negative news from around the world. Is there not a great marked for positive and good news?

“My main major prediction for The Tens is that it will represents a dramatic shift towards subscription based models for everything.”

With the launch of Spotify in the USA and Amazon in talks with book publishers on e-book subscriptions, I can safely say that this is the future. Still, many publishers, authors and artists have started to air their negative feelings around these services and withdrawn their products. It would had been very interesting to see how much artists such as Lacuna Coil have earned or lost from going away from Spotify in the last year. Will our kids even know about great bands such as AC/DC and Metallica, when their albums are unavailable on popular services such as Spotify? Do they really think that parents will go out and buy CDs for their kids, when they already pay a monthly subscription to millions of other songs?

“Television sets will include support for streaming videos over the Internet.”

Most new flat-screen TVs comes packaged with features, streaming over the network and Internet is just basic functionality today. YouTube is a must for any TV or TV-connected device, such as AppleTV and Blu-ray players.

Since this was for 2010, the iPad had not yet been announced…

“Apple will release an incredible, amazing, awesome tablet computing device. Google will continue to develop Google Wave and their OS will be largely ignored by the market”

Other predictions I made has more or less come true. Not exactly rocket science to predict what I did, so for next year I will make a quick list of my most important predictions.

My Top List of 2012 Technology Predictions

1. Quad-HD TVs will start to be available for consumers.
2. NASA will find further proof of water (and previous life) on Mars, with the event of Curiosity rover landing in August 2012.
3. Large Hadron Collider will make the Higgs boson particle no longer a hypothetical particle.
4. Microsoft releases Windows 8 and Windows Phone 8.
5. The biggest websites will all be HTML 5 based.
6. Apps (and games) built on HTML 5 will see exponential growth.
7. Millions more will play Massive Online Multiplayer Games.
8. Commercialization of space will take a giant leap forward.
9. Prototypes of robots that will “eat” our garbage to improve recycling of important metal and other materials.
10. New and improved humanoid robots will mimic human behavior – still years away from commercial use.
11. Global disasters due to weather changes.
12. Iran will be attacked.
13. Next generation of (Xbox) Kinect is announced.
14. I hope the first free-state is founded (Seasteading, Free State Initiative), but I doubt it.
15. More electric cars will see the day, resulting in loss of income to big oil and big government.
16. New buildings will become more and more self contained, producing it’s own power and potentially reusing/recycle some materials, such as water.
17. Many big and important online services will be hacked and have their customer details leaked.

(Photo by Marc Dalio)

Therefor I’m looking for new job opportunities in and around Kristiansand. Make sure you check out my résumé, which has all my contact details.

(Photo by Germán Póo-Caamaño)

A very good friend of mine, Ingo Rammer, did a talk at NDC 2011 on HTML 5. One of the best tip I got from his talk, was to start using Adobe AIR as the shell for your HTML 5 applications. As you might not be aware of, Adobe AIR includes the WebKit browser engine which more or less supports some of the HTML 5 features.

That means you can build a rich desktop application in HTML 5 which have access to local resources, such as the file system. Another neat feature is the cross-platform support between Windows and Mac. Unfortunately Adobe has quit their support for Linux.

Get the Adobe AIR SDK

First thing first, get the Adobe AIR SDK. After downloading and unpacking, you should add the path to the bin folder to your paths environment variable. this makes it quicker to build your application.

Building your first application

Create a new folder for your application on your computer, preferably you should use a source control, such as Mercurial. This makes it easier to recover from human errors.

To start off, I suggest using the HTML 5 boilerplate. I suggest going through the custom build and remove all the backwards compatibility features, as you are only going to be building for the WebKit browser.

In this folder, you can add your stylesheets, graphics, html, javascript and other resources you will be using in your application.

I suggest creating a file named Launch.bat which can be used during development and testing to launch your application.

Content of Launch.bat: adl.exe “MyIncredibleApp-app.xml”

Then you need to create your MyIncredibleApp-app.xml file, which is the manifest definition for your application. All this really needs, is the default HTML page it should render when starting up. Here is an example from one of my own applications:

<?xml version="1.0" encoding="UTF-8"?>
<application xmlns="http://ns.adobe.com/air/application/2.7">
    <id>FlickrDownloadr</id>
    <versionNumber>0.1</versionNumber>
    <filename>Flickr Downloadr</filename>
    <initialWindow>
        <content>Flickr Downloadr.html</content>
        <visible>true</visible>
        <width>800</width>
        <height>600</height>
    </initialWindow>
  <copyright>Copyright (c) 2006-2011 Sondre Bjellås.</copyright>
  <icon>
    <image16x16>icons/Flickr-Downloadr-16x16.png</image16x16>
    <image32x32>icons/Flickr-Downloadr-32x32.png</image32x32>
    <image48x48>icons/Flickr-Downloadr-48x48.png</image48x48>
    <image128x128>icons/Flickr-Downloadr-128x128.png</image128x128>
  </icon>
</application>

The next very important step, is to copy the Adobe AIR JavaScript files into your folder. Depending on your installation path, you should find the AIRAliases.js and AIRIntrospector.js files located here: AdobeAIRSDK\frameworks\libs\air. Copy these two files into your project and make sure you reference the AIRAliases.js in your web page. The AIRIntrospector you won’t be needing unless you are doing advanced debugging.

<script src=”AIRAliases.js”></script>

Make a wrapper around the JavaScript API

Going forward, with advances in browsers such as Internet Explorer, Chrome, FireFox and Opera – you might see that some actually already today – will support access to local resources. That means you can build web applications that doesn’t required Adobe AIR as a delivery mechanism.

For this reason, I suggest writing your own wrapper around the JavaScript API included with Adobe AIR. That means you won’t be directly dependent on Adobe AIR and it will make the transition to support other platforms and browser much smoother.

Here is an example on how to show a folder dialog using the Adobe AIR JavaScript SDK:

    var file = new air.File();
    file.addEventListener(air.Event.SELECT, dirSelected);
    file.browseForDirectory("Select a directory where you want to save photos.");

Launching your rich desktop web application

Next step is to complete your HTML page, I would suggest downloading libraries such as jQuery UI to add animations and other great features. While this post does not explain how to go from a development environment to releasing your app, I suggest referring to the Adobe AIR SDK documentation for additional features.

This is a starting point on how to get started and possibly preparing for a possible future of building great Windows 8 web applications.

Here is a screenshot of one of my own web based rich desktop applications:

The first part of this code example is based upon code from one of my colleagues (thanks Roy Tore), it’s basically a custom configuration element for your web.config, which allows you to define a list of services and the route it should be registered on.

Second element of this sample, is how the types are defined in the serviceType proprety in the web.config, which does not require a specific type, but support the use of interfaces. There is additional code in the example, which extends the WebServiceHostFactory with support for dependency injection using Autofac.

Walkthrough

Here is a walkthrough on how you can do this from scratch.

1. Create a new ASP.NET MVC 3 Web Application.
2. Install the Autofac.MVC3 NuGet package.
3. Add a reference to System.ServiceModel.dll, System.ServiceModel.Activation and System.ServiceModel.Web.dll
4. Download the Routing.zip and unpack this into your web project.
5. Modify the global.asax.cs, inside the Application_Start handler, add the following code in the beginning of the method:
   

   DependencyResolver.SetResolver(new AutofacDependencyResolver(CreateContainer()));

   And on the bottom of the method, after the ASP.NET MVC routes (RegisterRoutes):

   RouteTableManager.MapRoutes(DependencyResolver.Current.GetService<DynamicWebServiceHostFactory>());
   

6. Modify the same file, but this time inside the RegisterRoutes method. We need to make sure the regular ASP.NET MVC routing will ignore our special services URI. See the full example below, and here is the modified default route:
   

   routes.MapRoute(
       "",
       "{controller}/{action}/{id}",
      new { controller = "Home", action = "Index", id = UrlParameter.Optional },
      new { controller = "^(?!services).*" } // Important for WCF services to work.
       );

7. Create a new method called CreateContainer inside global.asax.cs, which creates your inversion of control container. Preferbly this should be placed somewhere else in a separate class. The first 3 registrations is to enable Autofac-support for your regular ASP.NET MVC controllers. After the changes, your global.asax.cs should look similar to this:

   public static void RegisterRoutes(RouteCollection routes)
   {
       routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
   
       routes.MapRoute(
           "", // Route name
           "{controller}/{action}/{id}",
        new { controller = "Home", action = "Index", id = UrlParameter.Optional },
        new { controller = "^(?!services).*" }
           );
   }
   
   protected void Application_Start()
   {
       // Set the MVC IOC resolver to our Autofac resolver.
       DependencyResolver.SetResolver(new AutofacDependencyResolver(CreateContainer()));
   
       AreaRegistration.RegisterAllAreas();
   
       RegisterGlobalFilters(GlobalFilters.Filters);
       RegisterRoutes(RouteTable.Routes);
   
       // Map all the routes configured in web.config.
       RouteTableManager.MapRoutes(      DependencyResolver.Current.GetService<DynamicWebServiceHostFactory>());
   }
   
   private IContainer CreateContainer()
   {
       var builder = new ContainerBuilder();
       builder.RegisterControllers(typeof(MvcApplication).Assembly);
       builder.RegisterModule(new AutofacWebTypesModule());
       builder.RegisterModelBinderProvider();
   
       builder.RegisterType<DynamicWebServiceHostFactory>();
   
       // Register all the WCF (REST) services.
       builder.RegisterType<ItemService>().As<IItemService>();
   
       var container = builder.Build();
       return container;
   }
   
   
   

8. Create your WCF (REST) Services (and modify the CreateContainer).
9. Modify your web.config with the example below and you are done!

Add the following to your web.config, right after the configuration elemenet:

  <configSections>
    <section name="routingExtention" type="

ConfigurableServiceRoutes.Routing.RouteTableSection, ConfigurableServiceRoutes, 

Version=1.0.0.0, Culture=neutral" />
  </configSections>

  <routingExtention>
    <routes>
      <add route="services/items" serviceType="

ConfigurableServiceRoutes.Services.IItemService, ConfigurableServiceRoutes, 

Version=1.0.0.0, Culture=neutral" />
    </routes>
  </routingExtention>

If you need more services, just keep adding into the routes collection with more add elements.

Next part of the config change, is to enable the ASP.NET Compatability. This is important for the sample to work.

  <system.serviceModel>
    <serviceHostingEnvironment aspNetCompatibilityEnabled="true" />
  </system.serviceModel>

That’s it!

Benefits

There are multiple benefits from this sample.

• Service Routing are configured, not compiled in code.
• Services does no longer require an empty constructor.
• Services supports dependency injection.
• WCF Services works fine together with ASP.NET MVC.

And that’s basically it, I hope you enjoy this for your own projects.

Source Code

You can download a fully working sample here: ConfigurableServiceRoutes.zip

When you run the sample, you will get a 404 on the root as it’s based on an empty ASP.NET MVC 3 Web App. If you access the URL with /services/items, you should see the WCF REST Service initialize correctly.

Notes of caution

There is one place in the code, inside the DynamicWebServiceHostFactory where I override the CreateServiceHost method. The logic that replaces the base here, I don’t know what the original code was and there might be special instances where your service instance won’t work properly. It works on my machine!

You have three option to install SQL Server Compact 4.0, using the Web Platform Installer, direct download, or you can add it as a NuGet package. I would suggest using the NuGet option, as that includes the required files with your source code. Make sure you get the documentation as well.

SqlServerCompact package: http://nuget.org/List/Packages/SqlServerCompact

With this package, you can start building code that queries and stores data in a file-based database. Yet, you still need one more package to make it work properly together with Entity Framework 4.1. Luckily, there is another NuGet package for this, EntityFramework.SqlServerCompact.

The SqlServerCompact package will try to modify your web.config/app.config with the following keys:

<configuration>
  <system.data>
    <DbProviderFactories>
      <remove invariant="System.Data.SqlServerCe.4.0" />
      <add name="Microsoft SQL Server Compact Data Provider 4.0" 

  invariant="System.Data.SqlServerCe.4.0" 

  description=".NET Framework Data Provider for Microsoft SQL Server Compact" 

  type="System.Data.SqlServerCe.SqlCeProviderFactory, System.Data.SqlServerCe, 

  Version=4.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91" />
    </DbProviderFactories>
  </system.data>
</configuration>

Also included in the package is the binaries for SQL Server Compact 4.0, located at the same level as your Visual Studio solution file, you should find this folder and within it all the assemblies needed to run: packages\SqlServerCompact.4.0.8482.1. Inside the lib folder is the System.Data.SqlServerCe.dll, which is the .NET assembly you need to work against SQL Server Compact.

The other package includes the assembly System.Data.SqlServerCe.Entity.dll, which contains code that generates proper queries against the SQL Server Compact. Additionally, it will add a source code file to your project inside the App_Start folder, that contains this code:

using System.Data.Entity;
using System.Data.Entity.Infrastructure;

[assembly: WebActivator.PreApplicationStartMethod(

typeof(InTheBoks.Test.Integration.App_Start.EntityFramework_SqlServerCompact), 

"Start")]

namespace InTheBoks.Test.Integration.App_Start {
    public static class EntityFramework_SqlServerCompact {
        public static void Start() {
            Database.DefaultConnectionFactory = 

              new SqlCeConnectionFactory("System.Data.SqlServerCe.4.0");
        }
    }
}

What happens here is that the default connection factory of the Entity Framework is changed to the provider specified in the web.config/app.config. While I was working on the previous builds of SQL Server Compact 4 and Entity Framework 4.1 CTPs, I did not have the provider changed in the web.config. The new key in the config made me wonder for what reasons it removed and added the provider again. So I investigated with an integration test project to see what really happens.

The default connection factory is SqlConnectionFactory. That means that we need to change the connection factory in the start up of our application, which is done with the code inside the Start method displayed above, which changes it to SqlCeConnectionFactory.

To investigate what the default configuration is, I had to access a list of factories using the API: DbProviderFactories.GetFactoryClasses(). This will give you a data table with rows for all the factories. I did this to figure out why the NuGet package made the changes to my web.config/app.config and to see if there was any difference to my already installed factory and the one added in the config. Conclusion was, there is no difference. The reason why the package adds the provider, is probably because the factory is not registered on the computer if you don’t install using the manual or Web Platform Installer – so it have to add it manually in the config. My suggestion is to keep the configuration key in place, this ensures that your application will work without the need to install SQL Server Compact.

Reference Table for DbProviderFactory Classes.

(Foto by Tim Morgan)

New version is being built entirely on HTML 5 and is using the latest of technologies available.

Here is a video preview of the new version, which demonstrates how I’m using AJAX to call the REST API to delete items in your movie catalog.

This new version will be released as open source and be a hosted service, that means you could build your own service just like InTheBoks and there are plenty of good code examples on how you can build modern HTML 5 applications on ASP.NET MVC 3.

Technologies and libraries in use:

• Entity Framework 4.1 RTW (Code First)
• SQL Server Compact Edition 4
• ASP.NET MVC 3 (Razor syntax)
• WCF 4 REST
• jQuery
• jQuery UI
• jQuery Templating
• Knockout JS
• Facebook SDK

You can follow the progress on the Facebook page: http://www.facebook.com/InTheBoks

Remember to also check out the official website where the new version will be released, hopefully sometime in 2011.

http://www.intheboks.com/

Use the promotion code: CRMIKEA

If you have any questions regarding Windows Azure, please feel free to leave a comment. Additionally, if you live in Norway and have a interest in cloud computing, have a look at the Cloud Computing group at The Norwegian Computer Association: https://www.dataforeningen.no/cloud-computing.160488.no.html

For small businesses and new startups this is a great product, which gets you started with collaboration tools within minutes, as oppose to expensive investement in servers, software, installation and maintenance. It even integrates

Go and visit the website to signup for the beta!

Recently I started using WordPress for my blogs and today I launched this blog on WordPress, and all my blogs will soon be running on WordPress. It’s a decent blog engine that has been around for a while and is pretty stable. It takes some work to import all your existing items, ensuring permalinks are intact and that photos still works. I imported 77 blog posts from the older blog and I hope all photos should work properly.

Recently I have been using Microsoft WebMatrix for some of my web development needs and for all new WordPress site I’m building, I start out with WebMatrix. It’s simply the easiest and fastest way to get started building your own custom blogs on WordPress.

Unfortunlately the FeedBurner service doesn’t link back to the permalinks but a combination that uses the GUIDs. Unfortunlately that means all the old links in my old feed URL won’t work, but the feed contained the full posts so it shouldn’t really matter much. The new feed URL will be http://sondreb.com/blog/feed

Importing from BlogEngine.NET using the BlogML format does not do categories properly, but it does import comments. Unfortunlately I had to use the RSS import and thus all my old comments on this blog are now gone. I might consider writing a script that imports them sometime in the future, but there was a majority of spam comments so hopefully it’ll be alright.

Until next time, you can take a look at my new front page which is also running on WordPress, sondreb.com.

Current Status

So the current status is that I have fully dynamic rendering for list of items and details on individual items. I have not yet added support for editing. The end results of what I’m working on, might be somewhat similar to the ASP.NET Dynamic Data technology from Microsoft. It does scaffolding of your data automatically. The difference obviously will be that mine are built on ASP.NET Web Pages and next version of Entity Framework. Other than sharing some general concepts, there are no similarities between my code and ASP.NET Dynamic Data.

Status Quo

Mikael Söderström made a good example on how you can combine Entity Framework and ASP.NET Web Pages, so I won’t bother doing the same. Check a bit down on this thread: http://forums.asp.net/t/1580303.aspx

What I want to avoid is the specific repositories, I want a single repository that is dynamic and can handle any entity type. I also want to avoid any logic inside the .cshtml that relates to the creation/reading of the entities. His example is still decent for those who want to go the “new, old route” of doing web development with Web Matrix. I’m on a mission to simplify this pattern.

Get Started

What I want to show today is how to dynamically create an instance of your entity and return that from your database. Create a new empty WebMatrix website and start writing some code.

Before we begin, make sure you have the latest version of Microsoft WebMatrix, SQL Server Compact Edition and Entity Framework CTP.

First you need to go through the example by Mikael that I linked too earlier, but you can replace the GuestbookRepository.cs with the code below and the default.cshtml will be different as well.

1. Create a new interface and call it IEntity. Just keep this empty for now.

2. Create a new class and call it Repository. Copy the code below:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.Entity;
using System.Web.Helpers;

/// <summary>
/// Generic repository for all of your entity types.
/// </summary>
public class Repository<TContext> where TContext : DbContext
{
    private TContext _context;
    private string _entityTypeName;
    private Type _entityType;

    public Repository(string entityTypeName)
    {
        _entityTypeName = entityTypeName;
    }

    public TContext Context
    {
        get
        {
            if (_context == null)
            {
                _context = CreateContext();
            }

            return _context;
        }
    }

    private TContext CreateContext()
    {
        _entityType = Type.GetType(_entityTypeName);

        // Make sure that only IEntity objects are returned for security reasons. You don't want
        // code that allows users to initiate any objects on the server.
        if (!_entityType.Implements(typeof(IEntity)))
        {
            throw new ApplicationException("The specified entity does not implement the required IEntity interface.");
        }

        // Create an instance of the DbContext.
        var context = Activator.CreateInstance<TContext>();

        return context;
    }

    private dynamic GetSet()
    {
        // Get an instance of the DbSet.
        var set = Context.Set(_entityType);

        // Load all the values.
        set.Load();

        // Get the query values.
        return set.Local;
    }

    public void Load(IEntity entity)
    {

    }

    public void Add(IEntity entity)
    {

    }

    public dynamic LoadAll()
    {
        return GetSet();
    }

    public void Delete(IEntity entity)
    {

    }
}

Unfortunately this code only does listing of all the entities, through the LoadAll method. In one of my later blog posts, I will provide example that does all the normal CRUD operations for your entities.

3. Create a new .cshtml file and call it what you want. Paste the following code into the new file:

@{
    var entityType = UrlData[0];
    var action = UrlData[1];
    var id = UrlData[2];

    if (string.IsNullOrEmpty(entityType))
    {
        Response.Write("There is nothing to see here... - Jim Carrey, \"Lifeguard on Duty\"");
        Response.End();
    }

    var repository = new Repository<BlogCatalog>(entityType);
    var result = repository.LoadAll();
    Page.Model = result;

    var grid = new WebGrid(Page.Model);
}

@grid.GetHtml()

The code has been simplified a bit, it doesn’t handle multiple types of listing. The “BlogCatalog” is the DbContext you created in the example by Mikael. Change that to whatever your own context is named.

Screenshot of the end result, this is the listing of my Author table.

The Beginning of By Convention

That’s the early beginning of the framework that will make it even easier and better to develop web apps using Microsoft WebMatrix and ASP.NET Web Pages. The combination of ASP.NET Web Pages with Entity Framework and doing the code by convention, gives us a powerful tool where we avoid duplicate code and we don’t have to repeat yourselves too often.

In The Beginning

Initially I was amazed with the incredible speed and power of the ASP.NET Web Pages Razor syntax and the Microsoft WebMatrix editor, in combination with the new IIS Express. Modifications was super quick to do, no compilation involved, it just worked and it rendered fast. I started out prototyping the web app and wrote lots of code inside the .cshtml files. Even included SQL code straight in the view files, this was the beginning of web development for me when I started out on classic ASP (Active Server Pages). After a while, I moved most of my SQL queries into classes that I kept in my App_Code folder. The Microsoft Data Helpers relied heavily upon the new dynamic type. All methods returned just a dynamic type, which I initially consider to be great and powerful, I could easily extend my types with any additional properties.

It was both easy and powerful to build my web app in this manner, but as my web app kept growing I realized I needed to make some improvements. From early on, I made a very conscious decision to not rely on any ORM (Object Relational Mapping). I didn’t want the requirement to compile or generate any code. Generated code is always bad. So there was no LINQ to SQL or Entity Framework for me… but that was until…

A New Beginning

… Microsoft released a CTP (Customer Technology Preview) for the next version of Entity Framework (EF). And off I went refactoring my code into relying on the Code-First capabilities of EF CTP. Instead of manually writing my SQL scripts, which I had done up until now, I relied on the Entity Framework to generate my tables automatically. Instead of writing SQL statements, I now wrote entity types, just simple Plain Old CLR Objects (POCO). For me, it’s much more natural to write simple C# objects than SQL statements and I get better type safety which avoids some bugs, but obviously removes the benefits of working with dynamic types as I did earlier.

Here is a typical example of one of my earlier entity types:

As I continued with my refactoring, a pattern started to emerge in my code base. I had my entity types, I had my catalog objects (DbContext), I had my static helper methods for all my entities and I still had a bunch of logic inside my .cshtml files to handle new elements, editing of existing elements, deletion of elements, validation of the model (user input) and often some other parts, such as the notification text to display when a save succeeded.

I started thinking that this is pointless, no developer should ever be put to write tedious repetitive code. I have lots of entities that I need the standard CRUD (Create, Read, Update, Delete) actions for and there is no chance I’m willingly going to write every single page for all of my entities. There is not legacy database, no legacy object types and no legacy requirement of any sort in my blogging framework, so I figured it was time to do more by-convention.

Don’t Repeat Yourself

So I started out thinking about how I could avoid repeating myself. I needed a convention for URLs, I came up with this current solution, will possibly change in the future, but for now it sticks:

http://url/Admin/EntityTypeName/View/FriendlyNameOrId

One example then, would be for the authors:

http://url/Admin/Author/View/admin

The type of actions I added was View, Edit, Delete, Create. View was planned to be used in the future if I add permission control that disabled the ability to edit the entity, but it’s not used much in the administration interface. Some of the guidance from REST is added here, but not all the concepts. The Delete action is only possible to do when you do a POST (or HTTP DELETE).

Here is a really simple example on how you can get the 3 input values from the URLs. All you have to do is create an Admin.cshtml file and then the above URL pattern will work just fine. UrlData won’t throw exceptions when you try to access index values that doesn’t exists, so there is no need to validate before you read the URL input.

Final Thoughts

One obvious question would be why I didn’t choose to do this in ASP.NET MVC 3? It already supports the HTTP verbs, good separation of views, models, etc. The simple answer is that I think ASP.NET Web Pages in combination with WebMatrix is simpler and I wanted to do this project to learn the new technologies. I’m already doing lots of ASP.NET MVC development on my daily job, so this was a fun experience to learn something new.

I’m currently researching how I can automate the views for all my entities, by configuration or simply by reflecting over my DbContexts? Right now, I’m investigating with reflection over my DbContext types, I’ll keep you updated in the next part on this blog series.

It’s a well established fact that our industry (software development) has a majority of male programmers. I think it’s important that we all promote the software engineering field towards girls, ensuring the future will have a higher percentage of girls who write code.

Today, the majority of software are developed by 20+ year old boys who develops software used by approx. 50% female users, often at twice the age of the developers. It’s one of the root causes of a lot of user frustration.

Writing Beautiful Code

Software developers care to little about beauty and elegance. We often stretch ourselves towards writing good unit tests and follow established object oriented best-practices. But we rarely think about how to make our architecture, design and code look beautiful. It’s not exactly in our nature, sort of speak.

As you can read in the excellent post on the same topic on the Creating Passionate Users blog:

“Because caring about things like beauty makes us better programmers and engineers. We make better things. Things that aren’t just functional, but easy to read, elegantly maintainable, easier–and more joyful–to use, and sometimes flat-out sexy. “

We should never forget that we rarely look at our own code more than once or twice, but eventually the code we write will be read by many others. It’s important to always recognize this fact and position ourselves in the minds of our fellow programmer.

Simplicity and Beauty

One of my mantra’s whenever I communicate with people through presentations and in my daily job, is to focus on simplicity. Making things simple is important, as a means to reduce complexity and improve communication.

Though it’s important to not forget about beauty and making things beautiful is similarly as hard as making things simple.

If you achieve simplicity and beauty you will be successful.

So from now on, try more to Code Like A Girl!

(This post is not meant to be sexist in any way, it’s a natural fact that females have a genetic advantage on beauty, one which we can learn from.)

Get your Code Like A Girl stuff from http://www.zazzle.com/code+like+a+girl+gifts.

The sample also includes a way to enable live language switching in your application, enabling the user to see language-change effects in real-time without restarting the application.

Markup differences

The binding syntax in XAML is somewhat awkward and it uses a lot of bracket ({  }). I wanted to avoid this and make it cleaner and more understandable. Have a look at this example on how you normally bind the content of a button to a static resource, which should be your generated resources class that the .resx file generates.

Content="{Binding About, Source={StaticResource Resources}}"

What this does is bind against the resource property About. You register the Resources property in your App.xaml file like this.

<resources:ApplicationStrings x:Key="Resources" />

What we want to do instead, is a syntax like the following example.

cirium:Resource.Key="About"

This is obviously much cleaner and communicates better than the first example. Resource.Key is a dependency property defines in the Cirium Application Framework. You don’t need to use Cirium to achieve this behavior, I have included the source-code below.

What’s the catch?

Obviously there are some small issues. The current implementation does not support resource text with format parameters (eg. “Welcome {0}”), I’m considering adding this in a future update.

Important: For this behavior and sample to work, you are required to modify the generated code-behind for your .resx file. You need to modify the constructor of your class and make it public, by default it becomes internal. You also need to modify the class to be partial, for the auto-magic update of all bindings to work properly. If you don’t do this, you can’t register your resource directly in the App.xaml.

You also need to manually add support for any controls I have not added in the dependency property class, currently it supports Button, TextBlock, TextBox and CheckBox. If you use any Silverlight Toolkit/SDK controls, you need to modify to specify which dependency property to bind against.

How does it work?

There is a simple class named Resource that handles the binding of controls with your resources. It’s important to notice that we use binding of the property instead of just setting the content directly from the resource. You might want to reconsider changing this if your application is not going to support multiple languages, but mine required to support multiple languages and be able to dynamically and quickly change between them without restarting the application or reloading the views.

There is one single requirement and that is that you register all your resources in the applications static resources collection under the name “Resources”. You can obviously change this in the class file as you see fit for your own project. Here is a screenshot that shows the sample application running, with localized content and tooltip.

Enabling your project for localization

When I first starting localizing my Silverlight application I was surprised how hard it was to figure it all out. It’s not enough to simply add the different .resx files to your project, you need to manually (even in Silverlight 4 with Visual Studio 2010) edit your project file with the proper languages you want to support. Unload your project, edit the content of it, locate the SupportedCulture XML element and add the languages you want to support. This example is for English and Norwegian.

<SupportedCultures>en-US;nb-NO</SupportedCultures>

To add multiple languages to your application, start by adding one .resx file to your project if you don’t have one. Fill it out with some values. Copy the .resx file to the same location in your project, and rename by adding the language (culture) code before the .resx file-ending. E.g. ApplicationStrings.nb-NO.resx or ApplicationStrings.en-US.resx.

Tip: You can localize the Out-of-browser settings by making multiple OUtOfBrowserSettings.xml files, just name them in the same way as your .resx files.

Tip: You can disable the code generation for your extra languages, Visual Studio won’t generate any content in your code-behind when you have multiple languages, only for the main language, so disabling the code generation in the extra .resx files will avoid generating empty files in your project.

Source Code

Below is the source code, it’s a simple working application in Silverlight 4, configured to run out-of-browser. It’s important to notice that you need to manually configure SupportedCultures if you need more languages than what’s in the sample.

Download the SimplifyResources sample project.

Here is the full source-code of the Resource.cs:

namespace SimplifyResources

{

    using System.Windows;

    using System.Windows.Controls;

    using System.Windows.Data;

    using System;

    public static class Resource

    {

        /// <summary>

        /// A dependency property for attaching a resource key to the element.

        /// </summary>

        public static readonly DependencyProperty KeyProperty =

            DependencyProperty.RegisterAttached(

                "Key",

                typeof(string),

                typeof(string),

                new PropertyMetadata(OnKeyChanged)

                );

        public static string GetKey(DependencyObject obj)

        {

            return (string)obj.GetValue(KeyProperty);

        }

        public static void SetKey(DependencyObject obj, string value)

        {

            obj.SetValue(KeyProperty, value);

        }

        /// <summary>

        /// A dependency property for attaching a resource key to the element used in the tooltip.

        /// </summary>

        public static readonly DependencyProperty TooltipProperty =

            DependencyProperty.RegisterAttached(

                "Tooltip",

                typeof(string),

                typeof(string),

                new PropertyMetadata(OnTooltipChanged)

                );

        public static string GetTooltip(DependencyObject obj)

        {

            return (string)obj.GetValue(TooltipProperty);

        }

        public static void SetTooltip(DependencyObject obj, string value)

        {

            obj.SetValue(TooltipProperty, value);

        }

        private static void OnKeyChanged(DependencyObject targetLocation, DependencyPropertyChangedEventArgs args)

        {

            SetupBinding(targetLocation, args, false);

        }

        private static void OnTooltipChanged(DependencyObject targetLocation, DependencyPropertyChangedEventArgs args)

        {

            SetupBinding(targetLocation, args, true);

        }

        private static void SetupBinding(DependencyObject targetLocation, DependencyPropertyChangedEventArgs args, bool isTooltip)

        {

            if (args.OldValue == args.NewValue) return;

            FrameworkElement element = targetLocation as FrameworkElement;

            if (element == null)

            {

                throw new Exception("Resource.Key can only be set on framework elements.");

            }

            // Load the resources source from the application’s StaticResources collection.

            // This will only work if you have added it to your App.xaml.

            var dataSource = Application.Current.Resources["Resources"];

            Binding binding = new Binding((string)args.NewValue);

            binding.Source = dataSource;

            if (isTooltip)

            {

                element.SetBinding(ToolTipService.ToolTipProperty, binding);

            }

            else

            {

                element.SetBinding(FindDependencyProperty(element), binding);

            }

        }

        private static DependencyProperty FindDependencyProperty(DependencyObject control)

        {

            DependencyProperty property = null;

            if (control is Button)

            {

                property = Button.ContentProperty;

            }

            else if (control is TextBlock)

            {

                property = TextBlock.TextProperty;

            }

            else if (control is TextBox)

            {

                property = TextBox.TextProperty;

            }

            else if (control is CheckBox)

            {

                property = CheckBox.ContentProperty;

            }

            return property;

        }

    }

}

Notes

If you get exception similar to this one, you need to modify the generated resources class.

No matching constructor found on type ‘SimplifyResources.Assets.Resources.ApplicationStrings’. [Line: 9 Position: 46]

The debate is stemming from a blog post by David Fowler and his example that shows how some data-related tasks have a simpler syntax with Microsoft.Data and the ASP.NET WebPages with Razor Syntax.

What is inside the Microsoft.Data namespace?

There is very little code inside the namespace and the assembly. It’s simply some helper types that makes life's a little bit easier. It’s not a new data access framework, like Linq to SQL or Entity Framework.

It contains the following classes: ConfigurationManagerWrapper, ConfigurationConfiguration, Database, DbProviderFactoryWrapper, DynamicRecord, IConfigurationManager, IDbFileHandler, IDbProviderFactory, SqlCeDBFileHandler and SqlServerDbFileHandler. Of which only Database and DynamicRecord are public available, the others are internal.

All data access inside the Microsoft.Data types are using the common ADO.NET types, not the providers specific for any SQL platform. This means it’s not restricted to SQL Compact Edition nor SQL Server. It relies on DbConnection, DbTransaction, DataTable, etc.

Microsoft.Data on ASP.NET Web Forms

While Microsoft.Data.dll is currently not accessible in the Add References dialog, you can find it by looking on your computer, it’s located in the Global Assembly Cache (GAC). Microsoft probably don’t want us to use it outside of WebMatrix in the current release… but if you just take a copy of the assembly out of the GAC, then you can reference the assembly in any .NET project and it will load it from the GAC (you just need the file so you can add a reference).

In my project I added a database to my App_Data folder (which you normally would never do, unless you are working with a local read-only cache in a large-distributed system or working with SQL Compact Edition) and added the following code to my web form, to make it render the Name column of my Users table.

	var db = Database.OpenFile("Database1.mdf");
	var users = db.Query("SELECT Id, Name FROM Users");
	foreach (var user in users)
	{
	Response.Write(user["Name"]);
	}
	

Take notice of the OpenFile parameter, it’s simply the filename on disk. I don’t have to care about any specific details of the connection string, nor how to figure out where the App_Data folder is.

Obviously though, if you added an entity framework (EF) model of your database, you would have very similar example to achieve the same and you don’t have to care about the connection string, at least not in theory.

	using (var db = new Database1Entities())
	{
	var users = db.Users;
	foreach (var user in users)
	{
	Response.Write(user.Name);
	}
	}
	

The two big distinctions betweens these examples is that the first one is dynamic, I can modify the database schema whenever I want and it won’t (necessarily) break my web app, while the latter example with EF will need to refresh the entity types based on the database model.

The other distinctions is that the first example doesn’t require a connection string, while the latter generates one for you automatically, a rather cryptic looking one.

<add name="Database1Entities" connectionString="metadata=

res://*/Model1.csdl|

res://*/Model1.ssdl|

res://*/Model1.msl;

provider=System.Data.SqlClient;

provider connection string="

Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|\Database1.mdf;

Integrated Security=True;

User Instance=True;

MultipleActiveResultSets=True"" providerName="System.Data.EntityClient" />

While all of this are peanuts for me and anyone who’s been developing on .NET for a while, I think that making things simple where possible is positive, rather than negative. It doesn’t mean we will stop using NHibernate, do proper n-tier and layered architectures just because Microsoft makes some tasks simpler for beginners. It also means some of us probably will eventually have to maintain and possibly migrate solutions built on Microsoft WebMatrix, but does that give us any right to restrict beginners the privilege of building their own solutions and feeling the immense joy of realizing their dreams?

Other’s feedback and comments

Ayende Rahien comments on his blog on the example, where he mentions the use Response.Write within the loop. Understandable this is probably not the best way to do this, but it’s understandable with the sample in question, which was already using Response.Write. There are slightly better examples available out there. He also points out that having the SQL queries directly in the view code is an open invitation for SQL injection. Using proper parameterized queries will reduce this potential security problem. Looks like David updated the sample to use parameters after the initial reactions. After the security push at Microsoft some years back, they really cleaned up their practices with examples in the MSDN documentations, I think we should expect the same level of security thinking on employee blogs as well.

Ayende quotes David, which (David) made the assumption that Microsoft.Data is tied to Sql Server in any way, which my investigations has shown is not correct.

David tried to respond to some of the feedback on embedding SQL directly in the view, with hacking around to get the new dynamic keyword to work properly with LINQ. To me, this defeats the whole purpose of simplicity with Microsoft WebMatrix, Razor and Microsoft.Data.

KristoferA comments on the post and suggests generating Linq to SQL datacontext using a page-level directive, which would essentially give the developer entity objects to work with (and query against). This again defeats the purpose of simplicity, and now you can no longer change the database scheme without “recompiling” your web-app.

The namespace naming is another sour point for some, and I can agree that there is little point is “abusing” the Microsoft.Data namespace for such a trivial little helper, perhaps Microsoft.WebMatrix.Data or Microsoft.Data.Connection?

Who is this for?

Microsoft WebMatrix (and ASP.NET WebPages) is not a tool built for “professional” programmers, additionally is it not a fully generic framework for building everything. It’s a domain specific language that is optimized for building simple web applications without to much resources.

It is not meant for enterprise applications that handles millions of transactions. Will it be used for that? Yes, it probably will! We’ve seen plenty of classic examples of websites that starts with simple web-frameworks and find themselves in big trouble when their services become popular. Services like Twitter and Facebook was not built to scale to their current levels, yet they started as simple concepts and services and has grown to become important services which affects global policies and real-life social interactions.

It's Not Rocket Science, But It's Our Work: http://blog.twitter.com/2008/05/its-not-rocket-science-but-its-our-work.html

And obviously, it’s for those of us who still miss the old days with ASP Classic, here is a pretty good (and funny) read, 8 Reasons to Stick with ASP 3.0 in 2006 (and 2007).

Final thoughts

It’s very clear that Microsoft WebMatrix (and related technologies) are primarily is focused towards beginners and it’s a great tool to build simple websites. I wouldn’t advice anyone to use this if you already know ASP.NET MVC and want to build complex web solutions, ASP.NET Web Forms, MVC or other more general purpose frameworks would probably be more fit.

Additionally I think it’s important to remember that WebMatrix is primarily focused on SQL Compact Edition for data access, the built in editor doesn’t allow you to modify SQL Server database. So the question (and response to some of the comments) is how many layers do you want to wrap your data access logic for a SQLCE database?

Been a while since Microsoft did a push towards simplifying development for beginners, when we went from VB6 to VB.NET, everything was more complex and the entry level for VB.NET is on-par with C#. With the release of .NET Framework 4, the complexity and total amount of features is mind blowing. I for sure welcome tools, languages and frameworks that simplifies how we develop software.

Simplicity is hard and it's something we should strive towards in all that we do.

Caliburn.Micro is smaller, more lightweight and it has a lot of good features that I think are useful when building rich applications for WPF, Silverlight and Windows Phone 7.

Caliburn.Micro have a focus on convention, meaning that it will automate a lot of the tedious tasks you normally have to do when you’re applying design patterns such as Model-View-ViewModel (MVVM, Presentation Model). Actions (commanding) can be achieved simply by naming your ViewModel operations with the same name as your Buttons and other action-controls in the View.

This new framework can reduce the complexity of your applications and make them cleaner and more adaptable to change in the future. Reducing complexity should always be one of the top priorities when building software.

(Note: The content of this article will probably become outdated as the Caliburn.Micro documentation is updated, though at the current time this is the only known example of IoC with Caliburn.Micro)

(Note July 9th 2010: As expected, Rob Eisenberg has updated the Caliburn.Micro documentation with an bootstrapper which uses MEF. If you’re a MEF-kind-of-programmer, check it out. I would still advice on using the Common Service Locator in the bootstrapper as oppose to directly working with the MEF-types. I don’t like binding my types to a specific IoC container, which you are with the MEF-attributes on your types and properties. With some IoC frameworks, you can simply use any custom interface and have your objects injected using Dependency Injection)

Inversion of Control

Inversion of Control is a pattern which helps separate the responsibility of creating objects from the classes which uses them. This can greatly enhance the way you can build a modular application which easier supports replacing existing logic and makes testing a whole lot simpler.

To learn more about IoC, see http://msdn.microsoft.com/en-us/library/ff647976.aspx

Building Caliburn.Micro

At the present time, there is no binary release of Caliburn.Micro available. You have to download the source code and compile it yourself using Visual Studio 2010. Head on over to CodePlex to get the source, http://caliburnmicro.codeplex.com/SourceControl/list/changesets

Caliburn.Micro is released under the MIT license, which means you can basically do almost anything you want with the source, even include it in your own product which is not open source. When you open the Caliburn.Micro solution file, you’ll see three projects, one for Silverlight, one for WPF and a last one for Windows Phone 7 (WP7).

Downloading Unity

Before you can continue to add IoC support for your WPF application, you need to download your favorite IoC framework. My favorite is Autofac, but for this demo I’m using Unity which is developed by the Microsoft patterns & practices group. Get the latest release from http://unity.codeplex.com/

Creating a new WPF project

Go ahead and create a new WPF project or open any existing project you might have. First step is to add reference to the following assemblies: Caliburn.Micro, System.Windows.Interactivity (included with Caliburn.Micro and my sample download at the bottom), Microsoft.Practices.Unity and finally the Microsoft.Practices.ServiceLocation. The ServiceLocation assembly is a common service locator assembly that has been built to provide a unified interface for all IoC frameworks.

Next you should follow the example in the documentation for Caliburn.Micro, it explains how to get the basic application up and working, see http://caliburnmicro.codeplex.com/wikipage?title=Basic%20Configuration%2c%20Actions%20and%20Conventions&referringTitle=Documentation

Creating a Container

If you got your basic application up and running with an empty bootstrapper, it’s time to create your IoC container. Create a new class in your project and name it Container. Create a single method can call it Build, returning IServiceLocator (found in the Microsoft.Practices.ServiceLocation namespace). This makes it possible for you to reuse this container type across other third party libraries which happen to play nice and supports the Common Service Locator.

    public IServiceLocator Build()    {        IUnityContainer unity = new UnityContainer();

        // Register our services.        unity.RegisterType<IFileService, FileService>();

        // Register all the ViewModels in our project.        foreach (Type t in typeof(ViewModel).Assembly.GetTypes())        {            if (typeof(ViewModel).IsAssignableFrom(t))            {                unity.RegisterType(t);            }        }

        // Return an type which implements the Common Service Locator interface.        UnityServiceLocator commonLocator = new UnityServiceLocator(unity);        return commonLocator;    }

Finishing the Bootstrapper

If you followed the example on the Caliburn.Micro site, you should have a empty bootstrapper. I called mine ClientBootstrap and it loads my ShellViewModel as the root element.

There are four operations you need to override to add your custom IoC container, they are Configure, BuildUp, GetAllInstances and GetInstance. If your Container class returns an IServiceLocator, you already have similar methods available. The only thing missing is the BuildUp. Unfortunlately there are no operation in the Common Service Locator interface for BuildUp, so either you have to revert to returning the IUnityContainer from your Build operation, or you might make it without the BuildUp override.

This is how my bootstrapper ends up looking.

    public class ClientBootstrap : Bootstrapper<ShellViewModel>    {        IServiceLocator _container;

        protected override void Configure()        {            Container container = new Container();            _container = container.Build();        }

        protected override void BuildUp(object instance)        {}

        protected override IEnumerable<object> GetAllInstances(Type service)        {            return _container.GetAllInstances(service);        }

        protected override object GetInstance(Type service, string key)        {            return _container.GetInstance(service, key);        }    }

Source Code

You can download the sample source code here. This sample is named “Flickr Downloadr” for the simple reason that I’m rewriting my popular photo download utility to WPF4, check out the existing version at http://flickrdownloadr.codeplex.com/

MVVM Project Structure

One of the first things you learn when searching for training material on MVVM in the context of Silverlight and WPF, is that many developers tends to chunk all their View Models and Views into a single project folder. This might work for a small project that has a minimal set of views, but for any bigger projects this will quickly become a mess so my advice is to avoid it altogether, you never know if your project will expand beyond your initial plans.

Either create a root-folder for all of your functional areas, or create a root-folder that contains all your features. I like to use the convention of a folder named simple “Features”. Within this folder, I create another folder for each distinct functional area of my app. Each functional feature can easily contain one or multiple views and view models.

On the right you can see an screenshot of the current structure for my InTheBoks project, where the ViewBase.cs from my previous blog post is stored under a Framework section.

With this structure, your View (e.g. MainView.xaml) and your View Model (e.g. MainViewModel.cs) will end up under the same .NET namespace, which is important when we want to load the view model by-convention.

What does by-convention mean? It’s simply figuring out the full type-name for the view model by following a defined project structure where we no longer need to manually connect the view and the view model.

Expanding the ViewBase

It’s time to expand the ViewBase we first defined in my previous post on No Code-Behind for MVVM. Inside the constructor of my PageView, UserControlView, WindowView (WPF) and ChildWindowView (SL), I set the DataContext with a call to an ViewBaseHelper class. This is done right after the InitializeComponent has been called using reflection.

DataContext = ViewBaseHelper.Instance.LoadViewModel(GetType());

The full source for my ViewBaseHelper is of course included in the sample download at the bottom, but here is the essential part that tries to load your View Model automagically:

internal object LoadViewModel(Type viewType){    if (viewType == null)    {        return null;    }

    var viewModelTypeName = viewType.AssemblyQualifiedName.Replace(viewType.FullName, viewType.FullName + "Model");

    var viewModelType = Type.GetType(viewModelTypeName);

    if (viewModelType == null)    {        return null;    }

    return Container.Resolve(viewModelType);}

In my example code I have relied upon Autofac as my choice for Inversion of Control container. The code that handles dependency injection is fairly small and can easily be replaced with an alternative IoC container.

What about design-time?

The method I’ve explained for convention based view model loading doesn’t work for design-time, which fortunately we have a solution for.

While this method does break somewhat with the idea of not directly binding the view to any view model type, this is only for design time and it can be very useful as you have a finer degree of control on which type you bind your view against and how you want it to be initialized.

All you need to do is add an d: element (which is ignore during compilation) which specifies the view model type and whether you want to create an actual instance of the VM or not. Here is an example from my MainView. First you need to import the namespace on which the view model is located and then set the d:DataContext attribute. IsDesignTimeCreatable is used to indicate if you want an object instance of the VM type.

xmlns:Feature="clr-namespace:InTheBoks.Features.Main"d:DataContext="{d:DesignInstance Type=Feature:MainViewModel, IsDesignTimeCreatable=True}"

asd

Create new Feature

One of the additional things I’ve done for InTheBoks, is to create templates for new features which creates the view and the view model with proper inheritance, namespace imports, and design-time binding. To do this yourself, simply add the correct .zip file with your template items in the following folder:

\Visual Studio 2010\Templates\ItemTemplates\Silverlight

I won’t go into further detail on this today, though this is a good thing to do if you’re working on a big project that has many views. This is how it can look when you customize your items with icons and illustrations.

Download the Source Code

While my previous example was built around WPF, this new one is built using Silverlight. As this concept and code is built around InTheBoks, the name of the sample and the namespace is “InTheBoks”.

The sample doesn’t include any advanced MVVM-technologies such as commanding, only the one that is built into Silverlight 4 which is binding. For the purpose of clarity, I removed any other external dependency than Autofac.

Here is the download: InTheBoks-2010-06-20.zip.

After discussing the problem with Peter Lillevold, he came up with a solution to our problem. Let’s first discuss the problem and then present the solution.

Initialize Component

When you look at a recently created XAML file, you’ll notice there is a call to the InitializeComponent in the constructor. This is an operation that is not available in the derived type (Window, Page, UserControl) nor is it directly visible in your project. Right-click on the method call and Go To Definition (F-12) opens an generated file you normally don’t see.

The operation is responsible for loading (initializing) the XAML which is embedded as a resource in your application binaries.

Example of a code-behind class:

public partial class MainWindow : Window{    public MainWindow()    {        InitializeComponent();    }}

Unfortunately the XAML views require this call to InitializeComponent to function properly, if you go ahead and delete the code-behind file you’ll end up with an blank window/user control when they are loaded.

View Base Types

The solution is to provide a view-base for all your top-UI containers, such as Window, Page and UserControl. These view-base types can additionally be used to construct convention-based initialization of View Models in an MVVM-pattern implementation. This is beyond the scope of this post, might be visited in a future post.

Here is an example on how to do this for a Window view:

public partial class WindowView : Window{    public WindowView()    {        var initializeComponentMethod = GetType().GetMethod("InitializeComponent",             BindingFlags.Public | BindingFlags.Instance);        if (initializeComponentMethod != null)        {            initializeComponentMethod.Invoke(this, new object[0]);        }    }}

First we tries to get an reference to the current instance of the object, which will return the inherited type (for example “ExampleView” type as included in my sample source code). Then we validate if the method actually exists and if it does, we invoke the InitializeComponent method.

Next step is to change the XAML markup so you no longer use the framework type for Window, Page or UserControl, but instead your own custom base view types. At this point you can delete the code-behind of your XAML files, just make sure you don’t delete any existing logic that you might have in your code-behind.

Side note: Having logic in code-behind is not a violation of good practices, even when you’re working with the MVVM (Presentation) pattern.

Open your XAML and add a statement that imports the CLR namespace where your view types are, e.g.

xmlns:NoCodeBehind="clr-namespace:NoCodeBehind"

Then change the root-XML-element in your XAML markup file to e.g.

<NoCodeBehind:WindowView 

Note that the x:Class element on the root element dictates the name of your view, meaning your XAML file can be named something other than the generated type of the view.

Example Source Code

For a concrete example of this implementation in WPF and how you can avoid the code-behind file altogether is included below. The two examples are ExampleView.xaml and ExampleControl.xaml which both works without code-behind files.

Please use the example with caution and there are no guaranties that the workaround doesn’t change some behavior in your running application. Any feedback is welcome, please leave comments!

Download the NoCodeBehind example in C#.

What are the reason we initiate IT-projects? It’s all about reducing complex problems to meaningful tasks that can be completed by humans.

Law of Software

Let’s focus on software development and what value software have for the users. Building software is what I and thousands of others are doing every single day, and we’re not exactly becoming better at what we’re doing, we’re actually only able to successfully complete aprox. 30% [2] of the projects that are initiated.

According to David S. Platt’s 3 Laws of Software, the software we build have zero value in and of itself. It doesn’t matter how technically good your code is, the only individual who cares are you and your own mother.

Platt’s 3 Law of Software [3] says the following:

1. Your software has zero value in and of itself. Only value it ever has is how it enhances the happiness of the user.

2. Software can increase users’ happiness in one of two ways. It can help a user accomplish a task that she wants done or it can give the user pleasure. Example: Outlook helps you read and write emails, HALO on the Xbox gives you pleasure and fun.

3. The users should not think about your computer program. At all. Ever.

(Click the link above to read the full law, I’ve just included the highlights)

What is writing software?

Writing software is the undertaking of understanding any arbitrary complex problem and writing software instructions to solve those complex problems.

The goal of writing software should be to reduce complex problems to simple tasks. Simple tasks that humans can initiate, often without requiring much need for thinking. The less the user is required to think, the happier and more productive they will be.

Thinking simple

When you have a complex problem you want to solve, what do we tend to use as mechanisms to solve them? It’s obviously not thinking in simple terms, this is pretty obvious when you look at the software we’re building.

As our understanding of a complex problem increases (as we work out the details of a software design), we can’t seem to be able to come up with simple solutions, we often take this route of thinking: Complex problems requires complex solutions.

This is wrong, and it’s the root cause of so many software project failures.

We need to start thinking simple. We need to figure out how we can reduce the complex details of a design, until we have an design and architecture that is as simple as possible and still delivers the value for our users.

Our goal should be: Least complex architecture possible [4].

There are many reasons why something ends up being complex, one important factor is the amount of functionality we put into our software. According to Robert L. Glass [5] in his book Facts and Fallacies of Software Engineering, the fact is as following, 25% increase in functionality increases complexity by 100%.

Next time you are faced with a complex problem that someone wants to be solved using software, start by thinking about the users and how you can increase their happiness. Then start reducing the initial complex solution of the complex problem, into the most simple solution you can which still achieves the goal: Making your users happy!

References

[1]: http://www.objectwatch.com/white_papers.htm#ITComplexity

[2]: The CHAOS report by The Standish Group (http://www.standishgroup.com/)

[3]: http://msdn.microsoft.com/en-us/magazine/ff646970.aspx

[4]: http://sondreb.com/blog/post/MSDN-Live-Solution-Architecture-Slides.aspx

[5] http://www.robertlglass.com/

[Photo]: http://www.flickr.com/photos/kodomut/

I’m currently using this for the coming version of InTheBoks, which will from now on use Facebook Connect for authentication. While working on this integration, I realized that the Facebook Developer Toolkit never raises any events back to the Silverlight application when it loads the first time and tries to look for a persistent cookie. Learn how you can extend the toolkit so you can improve the user experience of your Silverlight applications that integrates with Facebook.

This post does not describe how to get started with the Facebook Developer Toolkit and Silverlight, this is just a quick way you can improve the authentication processes with Silverlight.

Requirements

First you need to get the source code for the Facebook Developer Toolkit. We need this so we can extend the BrowserSession.cs file.

BrowserSession

Start by extending the BrowserSession class with an event handler and one method that will be executed from the fblogin.js JavaScript file. Since we are editing an existing framework, we don’t want to change any existing implementations of code so we’ll add an extra event handler like this:

public event EventHandler NotAuthenticated;

The next step is to add an method that is called from JavScript:

[ScriptableMember]
public void NotLoggedIn()
{
    if (NotAuthenticated != null)
    {
        NotAuthenticated(this, EventArgs.Empty);
    }
}

fblogin.js

Open the fblogin.js file that is included with the Facebook Developer Toolkit and should be at the root of your web application that hosts your Silverlight app.

Find the function isUserConnected, which should look like this:

function isUserConnected() {
    FB.ensureInit(function () {
        FB.Connect.get_status().waitUntilReady(function (status) {
            var plugin = document.getElementById(‘_sl_facebookapp’);
            facebook_getSession();
        });
    });
}

Replace the above function with this updated one:

function isUserConnected() {

    FB.ensureInit(function () {
        FB.Connect.get_status().waitUntilReady(function (status) {

            var plugin = document.getElementById(‘_sl_facebookapp’);

            switch (status) {
                case FB.ConnectState.connected:
                    facebook_getSession();
                    break;
                case FB.ConnectState.appNotAuthorized:
                case FB.ConnectState.userNotLoggedIn:
                    plugin.Content.FacebookLoginControl.NotLoggedIn();
            }
        });
    });
}

That’s all you need to change to enable a way to get a callback when the JavaScript have checked if the user is authenticated or not.

Notes on the UI

With this additional event, you can now hook up to three events to update your UI. Here is the code from the constructor in my ViewModel.

_session = new BrowserSession(ApplicationKey, new Enums.ExtendedPermissions[] { Enums.ExtendedPermissions.offline_access });
LoginButtonText = "Loading…";
_session.NotAuthenticated += new EventHandler(Session_NotAuthenticated);
_session.LoginCompleted += new EventHandler<System.ComponentModel.AsyncCompletedEventArgs>(Session_LoginCompleted);
_session.LogoutCompleted += new EventHandler<System.ComponentModel.AsyncCompletedEventArgs>(Session_LogoutCompleted);

I have a single HyperLinkButton that have it’s content bound to a string property named LoginButtonText. This is displaying “Loading…” when the app is loading, then depending on which event is raised, I change the LoginButtonText to “LOGIN” if the NotAuthenticated event is raised, “LOGOUT” if the LoginCompleted is raised and back again to “LOGIN” if the user logs out.

For more background on the presentation, also read my blog post that I wrote during the preparations. The final result is very different than I initially planned and I didn’t deliver what was promised in the agenda. I still hope the presentation gave enough value to those who attended and I hope it inspired to enable change and sparked a move towards simpler solutions with reduced complexity.

Enjoy!