Fredrik Normén

Build, first day

2011-09-14T13:21:00Z

It was an interesting day at the Microsoft Build Conference. I will in this blog post share some of the things that were presented during the first Keynote and big screen day.

The keynote started to present Windows 8, and the Metro (The new GUI). Focus was on the new user experience and UI. As many of you have probably already seen, the UI is similar to Windows Phone 7 and is created for touch. The idea of the Metro UI is to bring everything in front of the user, easy to find what they want and need. Microsoft wanted to make Windows 7 even better. Everything that runs on Windows 7 runs on Windows 8.

They reimage Windows to experience a new range of capabilities, scenarios, and factors. Windows 8 uses about 281 Mb memories and in the size an antivirus program is also running. One feature I like the most was the Spell Checking through the whole system Windows 8 will be a great new platform for developers.

Developers can use the new WinRT API to build great apps, they can use different kind of languages, like HTML/CSS and Java-script, XAML and C# or VB, C or C++. The interesting part is HTML and Java-script. It will make it much easier to move web developers into writing Mobile apps and Windows 8 apps in an easy way. App developers want rich connectivity and sharing capabilities, connection to customers. Reach every customer using Windows. Touch will be the future, and the WinRT deliver it all. Developer can use the WinRT APIs for Communication & Data, Graphics & Media, Devices and Printing. Contracts can be used to make app communicate with each other, an example of an Contract is the "Search Contract", that can be used to hook up an app into the Windows 8 "search engine". There are different ways apps can communicate with each other, loacaly, Scheduled or with Push (using Windows Push Notification WSN). With Tiles developer can extend the apps with information instead of using an icon.

Developers will get a set of great of tools for writing Windows 8 apps. With Visual Studio 11 and Expression Blend 5, developers can be up and running in a short time by using predefined templates. Expression Blend 5 will now handle HTML and Java-script, and Blend is now integrated into Visual Studio 11. Visual Studio 11 also has a simulation feature when it comes to debugging, so developers could select for example a Slate and hit debug, and a simulation of a Slate will appear.

The new platform will have a great set of Could Services to make it easier to share images etc with friends over the cloud, apps working together. Apps are connected to each other and the cloud. Pull information from other apps. A tiny API can be used for this for developers. Microsoft will also give developers and customers access to Windows Store, it will make it much easier to buy and sell apps. This will probably also boost and increase development of apps for Windows 8. Within Visual Studio 11, developers can easily package apps and publish them to the Windows Store; they just use the Store menu in Visual Studio 11.

Everyone at Build got a Developer Preview of Samsung’s iCore5 Slate with a Developer Preview of Windows 8, Expression Blend 5 and Visual Studio 11 Express. So now the fun can begin. You can download the bits by yourself at the Windows developer center: http://dev.windows.com. If you follow me on twitter (@fredrikn), you can read more about what will be presented during the conference. Tomorrow there will be a keynote, and then a lot of sessions, I will probably attend the HTML5 sessions and some other sessions like ASP.NET 4.5 and C# 5 etc.

Update on ASP.NET Vulnerability

2010-09-25T07:15:36Z

Scott Guthrie updated his blog with more info about the ASP.NTE Vulnerability, check it out here: http://weblogs.asp.net/scottgu/archive/2010/09/24/update-on-asp-net-vulnerability.aspx

Vulnerability in ASP.Net

2010-09-18T08:18:58Z

I would recommend all of you who are managed ASP.Net application to read this:

http://blogs.technet.com/b/msrc/archive/2010/09/17/security-advisory-2416728-released.aspx

Make sure the web.config pages/namespace can be used together with ASP.NET MVC 3 P1 and Razor

2010-08-04T09:24:00Z

Note: This blog post is based on the ASP.NET MVC 3.0 Preview 1.

The following section is from Forkcan.com (If you didn’t know, you can get code shared to ForkCan.com on your blog, read more here about it).

If you want to know when I publish a new blog post you can follow me on twitter: @fredrikn

ASP.Net MVC 3.0 Preview 1, Razor and nested master pages

2010-08-01T08:16:40Z

Note: This blog posts is based on the ASP.NET MVC 3.0 Preview 1.

In this blog post I will explain how I have created a nested master page in ForkCan.com.

Here is the master of the master pages ;) (_Loyout.cshtml) (I have removed some HTML from this example only to reduce the code):


@inherits System.Web.Mvc.WebViewPage
@using ForkCan.Web.Infrastructure.WebPageHelpers

<html xmlns="http://www.w3.org/1999/xhtml" >
<head id="Head1" runat="server">
    
    <title>@View.Title</title>
    
    @RenderSection( "TitleContent", optional : true)

</head>
<body>

    <div class="centerBlock">
        
       ...

        <br class="clear" />

        <div id="header">
            <div id="topBar">
                <div id="topMenu">
                    <div class="nav">
                        <ul>
                            <li><a href="/">Code</a></li>
                            @if (WebSecurity.IsAuthenticated) {
                                <li><a href="/user/login">Log in</a></li>
                            } else {
                                <li><a href="/user/logout">Log out</a></li>
                            }
                           </ul>
                    </div>
                </div>

            </div>

            <div id="ch"/>

            ...

        </div>

        <div class="clear">

            <div id="mainmasterContent">

            @RenderBody()

            </div>

        </div>

        ...
 
        @Google.GetAnalyticHtml()

   
</body>
</html>

Something to point out in the _Layout.cshtml is the @RenderSection and @RenderBody mehtods. When using Master pages with Razor we can add the @RenderBody method where we want our “main content” of our content page to be located. If we want to specify some kind of “content place holders” we can use the @RenderSection methods. ForkCan.com has two “Content place holders” in the _Layout.cshtml, the RenderBody and the "RenderSection “TitleContent”. The TitleContent can be used from a “content page” to add styles, client-side scripts etc to the header of the _Layout.cshtml. To create a nested master page we just need to create a new “cshtml” file and then use the LayoutPage property to point to the master page we want our nested to be used (_TwoColumnsLayout.cshtml):

@inherits System.Web.Mvc.WebViewPage

@{
    LayoutPage = "~/Views/Shared/_Layout.cshtml";
}

<div id="right-content">

    @RenderSection("RightContent", optional : true)

</div>

<div id="content">

@RenderBody()

</div>

The content of the code above will be rendered where the @RenderBody of the _Layout.cshtml is placed. The nested masterpage in ForkCan.com have one “content place holder” added “RightContent” and the @RenderBody where the content of the content pages which will use the nested masterpage will be rendered. As you can see it’s quite easy to create nested master pages with Razor.

The following is one content page using the _TwoColumnsLayout.cshtml (It’s the view that renders the list of shared codes on Forkcan.com):

@inherits System.Web.Mvc.WebViewPage<ForkCan.Models.PresentationModel.ListOfShareCodes>
@using ForkCan.Web.Infrastructure.Extensions
@using ForkCan.Web.Infrastructure.WebPageHelpers

@{
    View.Title = "ForkCan - Top Used Code";
    LayoutPage = "~/Views/Shared/_twoColumnsLayout.cshtml";
}


@section RightContent
{
    <script src="/Scripts/jquery.tools.min.js" type="text/javascript"></script>

    <div class="rssFeed">
        <a href="@Model.FeedUrl"><img class="feedback" src="/content/rss.png" />@Model.FeedTitle</a>
    </div>

    <div>
        <span style="font-weight:bold;">Latest activity</span>
        @foreach (var activity in Model.LastActivities) {
        <div class="activityItem">
            @(new HtmlString(activity.ActivityText))
        </div>
        }
    </div>
}


    <div class="viewHeader">
        
        <h1>@Model.Header</h1>

        <div id="filters">
            <a class="@(Model.OrderBy == "views" ? "selectedFilter" : "")" href="@(Model.ListUrl + "?orderby=views&search=" + Server.UrlEncode(Helper.Request.Search))" title="Order by views">Credits</a>
            <a class="@(Model.OrderBy == "used" ? "selectedFilter" : "" )" href="@(Model.ListUrl + "?orderby=used&search=" + Server.UrlEncode(Helper.Request.Search))" title="Order by most used code">Used</a>
            <a class="@(Model.OrderBy == "newest" ? "selectedFilter" : "" )" href="@(Model.ListUrl + "?orderby=newest&search=" + Server.UrlEncode(Helper.Request.Search))" title="Order by newest code">Newest</a>
            <a class="@(Model.OrderBy == "oldest" ? "selectedFilter" : "" )" href="@(Model.ListUrl + "?orderby=oldest&search="+ Server.UrlEncode(Helper.Request.Search))" title="Order by oldest code">Oldest</a>
        </div>

   </div>
   
    <div id="container">
   
    @foreach (var code in Model.Items)
    {
        <div class='mySharedCodeItem'>

            <div id="shareCodeRating">
                <br />
                <span title="Number of views">@code.Views</span><br />
                Views
            </div>

            <div id="shareCodeItemLeft">

                <a href='/viewcode/@code.CodeId/@code.TitleInUrl' class="sharedCodeListItemTitle">@code.Title</a><br />

                <span class="posted">
                By <a href="/user/view/@code.CreatedById/@code.CreatedBy.ToUrlTitle()" class="sharedCodeListItemPostedBy" title='@(code.CreatedBy + " created this code")'>@code.CreatedBy</a>
                &nbsp;@code.CreatedByTitle&nbsp;
                @code.Created</span>

                <br />

               <br />
               <span class="codeDescription">&quot;@code.ShortDescription&quot;</span>

               @Html.Partial("_tags", code.Tags)

            </div>
            
            <div id="shareCodeItemRight">

                <div class="feedbacks">
                    <img class="feedback" title="Number of users used this code" src="/Content/used.png" /> @code.Used
                    <img class="feedback" title="Number of positive feedback" src="/Content/positive.png" /> @code.PosetiveFeedback
                    <img class="feedback" title="Number of negative feedback" src="/Content/negative.png" /> @code.NegativeFeedback
                    <img class="feedback" title="Number of discussions about the code" src="/Content/discussions.png" /> @code.Discussions
                </div>

            </div>

            <br style="clear:both;" />
         </div>

        <div class="sharedCodeItemEnd"></div>
    }

    @Pager.Render(Model.SelectedPage, 15, Model.TotalNumberOfCodeBlocks, Model.ListUrl + "?page={0}&orderby=" + Model.OrderBy +"&search=" + Server.UrlEncode(Helper.Request.Search));

    </div>

    <script type="text/javascript">
        $("a.tagLink").tooltip(
            {
                effect: 'toggle',
                position: 'bottom center'
            });
    </script>

The main content of the content page will be rendered where the @RenderBody method is located in the "_TwoColumnLayout.cshtml nested master page. To place something into the “content place holder” RightConent, we can in razor add a “content control” by using the @section syntax, the following code inside of the @section will be placed where the @RenderSection(“RightContent”) is located in the nested master page:

@section RightContent
{
    <script src="/Scripts/jquery.tools.min.js" type="text/javascript"></script>

    <div class="rssFeed">
        <a href="@Model.FeedUrl"><img class="feedback" src="/content/rss.png" />@Model.FeedTitle</a>
    </div>

    <div>
        <span style="font-weight:bold;">Latest activity</span>
        @foreach (var activity in Model.LastActivities) {
        <div class="activityItem">
            @(new HtmlString(activity.ActivityText))
        </div>
        }
    </div>
}

Summery

By using the LayoutPage property we can specify which master page we want to use. The @RenderBody should be used and places where the main content of a content page’s content should be rendered. By using the @RenderSection we can create “content place holders”, and fill them with content from a content page by using @section.

If you want to know when I publish a blog post to my blog, then you can follow me on twitter: @fredrikn

UnitOfWork Action filter for ASP.NET MVC and nHibernate

2010-07-27T14:26:00Z

Loading Strategy for Entity Framework 4.0

2010-07-25T10:23:00Z

Integrate your blog or sites with ForkCan.com

2010-07-25T09:20:00Z

If you didn't know, you can get the code you have posted on ForkCan.com and include it to your blog posts or sites. The following is an instruction (The Instruction itself is included from ForkCan.com):

If you want to know when I have published a blog post, then you can follow me in twitter: @fredrikn

ForkCan is now available public – Share, Discuss, Improve code etc

2010-07-11T13:19:00Z

ForkCan is now available, you can read more about ForkCan here. If you have an idea of a code, or want to see if it can be improved, want to find code for your project etc or talk about code. Then ForkCan is a place for you..

ForkCan

Feedback

What is ForkCan.com – Do you have what it takes to Share your code?

2010-07-10T09:20:18Z

I have worked on a project for a while now, I call it ForkCan and can be found on the following URL www.forkcan.com. ForkCan is all about sharing code in a social way. I have notice that several developers on twitter paste pointers to sites like paste-it.net to share some code with others, and to get feedback on the code. I moved this a little bit further and created a similar site BUT! I also want to make sure developers can learn from each other, discuss the code with each other and much more. There are so many great code examples shared and distributed on the web, but to find them we need to search for it and it’s spread around different blog posts, forums etc. I wanted to create one place where developers can add the code, make a repository of codes where everyone can find great code to be used in a project. I also created ForkCan to save my own “good to have” code snippets, so I can find it easy and and copy and paste it into my projects. You may wonder why I call it ForkCan? It’s because it can be used as a can of forks ;) Fork in Software development is about taking an existing code and make development on it. So with ForkCan you can share your code, someone else can make it even better by making a Fork of it. The idea of ForkCan is to help each other to be better developers. The site also is a great tool for the Copy & Pasters.. ;)

The feature ForkCan supports today are:

1) Share Code (Anonymous or as a registered user)

2) Add tags

3) Give feedback (Positive, neutral and Negative) – feedback adds rating to the code.

4) Rate the code (Is not yet implemented, but the rating is displayed)

5) Make a Fork of the code and see the Fork in a tree form

6) Discuss the code (will give points to the user that wrote the comment), in the future comments can be rated (the model is in place but not the code).

7) User Titles (User can get different titles based on contributions)

8) User Scoring

9) Search for code

10) Use OpenId

11) Markdown for the content of the shared code

I have much more features on my list to do, like Achievements, some sort of badges and advanced search etc. I will also work more with the User Interface, add more tips and helps to the site, a way to easily post Feedback about how to improve ForkCan and also report bugs etc.

The rest part of this post is how ForkCan looks like today and about some of the features that are added at the moment.

First Page

First page will show a list of all the shared codes, it will by default be listed in a order where the most used code will be at the top.
Note: At the moment the sorting is not yet implemented.

The list shows the title of the code a developer have shared, a short description of the code, tags (there is not a predefined list of tags, just create your own tags), information about the code, such as when it was created, created by and the current points the user who created the code has. The smalls icons above the creator of the code shows the number of views, number of devs who have used the code, number of positive, neutral and negative feedback and also number of discussions (Should I add number of forks?)

To Share a code, you simply press the big Share Code button at the right top corner under the search textbox.

Share Code

Anyone can share codes, ForkCan uses OpenID for users that want to register them self on the site (gives of course a lot of benefits, such as making a fork, give feedback to other users etc.) You can share code by just mark the code with a name. Here is how the Share Code form looks like today:

ForkCan use the WMD RichTextArea control. The WMD control uses Markdown. I will later add a better help for how to you use Markdown, if you are familiar to StackOverflow you will know hot to use it. When you add a code block remember that you need to indent the code with 4 spaces. You can use some HTML tags and also add links.

You can share code and login at the same time by specifying an OpenId, if you aren’t a registered user you will come to a Edit profile form to enter some information about your self:

ForCan uses Gavatar for handling avatars. If you have earned one or more titles, you can select a title that will be displayed together with your user information when user are watching your code. The 20 first registered users will get three titles “No. 1” , “I was first here” and “1337”.

View code

When you select a code to view from the list of code from the start page, you can as a registered and authenticated user post feedback to the user who has created the code (You will earn points if you post feedback, and the user who shared the code will also earn points as long as it’s positive feedback), you can also create a Fork or write comments about the code.

The following is a view where feedback, forks and comments are added:

I hope you will like ForkCan.com and I also hope this site will bring value to you as a developer and also to other developers. A Beta will be out later this day (the time from when this post was created) or tomorrow. I hope some of you are interested to do some contribution and also be a beta user.

Hope to see you all at ForkCan.com

If you want to know when I have published a new blog post, then follow me on twitter: @fredrikn

Microsoft WebMatrix – Easy way to build ASP.NET Web Sites

2010-07-07T04:26:00Z

Yesterday Microsoft announced WebMatrix, a tool to build standalone ASP.NET Pages using the new Razor view eninge. With WebMatrix developers will get the new IIS Developer Express and SQL Compact Edtition.

The idea of WebMatrix is to make it easy for developers to build web sites, not yet suitable for Enterprise Apps in my opinion, more for devs that want to get started really fast. With WebMatrix we will get a tool to easily create a Site, Browse our files, manages our database etc:

The tool is easy to use, easy to learn and manage. You don’t need to have Visual Studio to create a simple ASP.NET website. The following is an image editing a file within the tool:

Razor is a new View engine which can be used to write ASP.NET Web pages, the "Razor" view engine together with WebMatrix reminds me a lot about classic ASP pages but using .Net, something that I like. It will make it much easier for those devs that find it hard to move from classic ASP to ASP.Net. Here is an example why I think WebMatrix and "Razor" reminds me of classic ASP pages, the code will read from a database and list members that belongs to a specific group, the value of the group is taken from the QueryString “group” by using the Request helper method:

@{
   string group = Request[“group”];

   var db = Database.Open("Members");
   var members = db.Query("SELECT * FROM Members WHERE Group = @0", group);
}

<html>
      <head>
               <title>List members</title>
      </head>
      <body>
                <ul>
                   @foreach (var member in members) {
                      <li>@member.FirstName - @member.LastName</li>
                    }
                 </ul>
      </body>
</html>

I like this way of writing a small app and the Razor’s much cleaner syntax. Have in mind that Razor view engine with ASP.NET MVC can be used for enterprise apps. Using Razor with WebMatrix will not target entperise apps developers in first place.

Handling “submit “ HTTP Post and also caching is quite easy. To check if a Post is made, we can use the IsPost property, to cache information we can use the WebCache helper, the following is just a fast example I put together to demonstrate the use of IsPost and WebCache helper,

@{

     var minutesToCache = 10;
     var useSliding = true;
     string data = string.Empty;

     if(IsPost)
     {
           data = Request["myData"];

           if (WebCache.Get("Key") == null)           
                WebChache.Set("Key", data, minutesToCache, useSliding);
     }

    if(WebCache.Get("Key") != null)
          data = WebCache.Get("Key").ToString();
 }

<html>
      <form ..>
           <input type="text" name="myData" value="@data" .../>
           <input type="Submit" ..../>
      </form>
</html>

With Razor we will get some social Web Helpers, for example Twitter, Gavatar etc:

<body>
      @Twitter.Search("WebMatrix")
</body>

We can also an easy way create Code-based helper method, Microsoft is looking for supporting HTML Helpers, to globally share helpers among pages. Here is an example of a HTML Helper (will not work in the beta):

@helper RenderMembers(List<Member> members) {
   <ul>
      @foreach (var member in members) {
        <li>@member.FirstName @member.LastName</li>
      }
   </ul>
}


<body>
    @RenberMembers(Model.Menbers)
</body>

If you want to know when I have published a new blog post, follow me on twitter: fredrikn

“Razor” the new ASP.NET View Engine

2010-07-06T04:01:50Z

Because of my work with the www.forkcan.com and the traveling around Sweden talking about ASPEN a Silverlight 4, MVVM, RIA Services, Unity 2.0, MEF application I haven’t spend so much time with blogging.

“Razor” is a new view engine for ASP.NET, you can get more information about it on Scott Guthrie’s blog. Here is an example of a old server-side script block in ASP.NET:


<h1><%: title %></h1>

<% foreach (var item in items) {%>
<span><%: item.FirstName %> <%: item.LastName %></span><br/>
<%{%>

With “Razor” the above code can look like this:


<h1>@title</h1>

@foreach (var item in items {
  <span>@item.FirstName @item.LastName</span><br/>
}

“Razor” uses a new file suffix “cshtml” or “vbhtml”, where the prefix is the language used in the file.

What I like the most with “Razor” is the new way to use expressions and the cleaner server-side code blocks.

If you want to know when I will publish a new blog post, then you can follow me on twitter: @fredrikn

Design by Contract with Microsoft .Net Code Contract

2010-06-05T09:54:00Z

I have done some talks on different events and summits about Defensive Programming and Design by Contract, last time was at Cornerstone’s Developer Summit 2010. Next time will be at SweNug (Sweden .Net User Group). I decided to write a blog post about of some stuffs I was talking about.

Users are a terrible thing! Protect your self from them

”Human users have a gift for doing the worst possible thing at the worst possible time.” – Michael T. Nygard, Release It!

The kind of users Michael T. Nygard are talking about is the users of a system. We also have users that uses our code, the users I’m going to focus on is the users of our code. Me and you and another developers.

“Any fool can write code that a computer can understand. Good programmers write code that humans can understand.” – Martin Fowler

Good programmers also writes code that humans know how to use, good programmers also make sure software behave in a predictable manner despise inputs or user actions.

Design by Contract

Design by Contract (DbC) is a way for us to make a contract between us (the code writer) and the users of our code. It’s about “If you give me this, I promise to give you this”. It’s not about business validations, that is something completely different that should be part of the domain model. DbC is to make sure the users of our code uses it in a correct way, and that we can rely on the contract and write code in a way where we know that the users will follow the contract. It will make it much easier for us to write code with a contract specified. Something like the following code is something we may see often:

public void DoSomething(Object value)
{
   value.DoIKnowThatICanDoThis();
}

Where “value” can be uses directly or passed to other methods and later be used. What some of us can easily forget here is that the “value” can be “null”. We will probably not passing a null value, but someone else that uses our code maybe will do it. I think most of you (including me) have passed “null” into a method because you don’t know if the argument need to be specified to a valid value etc. I bet most of you also have got the “Null reference exception”. Sometimes this “Null reference exception” can be hard and take time to fix, because we need to search among our code to see where the “null” value was passed in etc. Wouldn’t it be much better if we can as early as possible specify that the value can’t not be null, so the users of our code also know it when the users starts to use our code, and before run time execution of the code? This is where DbC comes into the picture. We can use DbC to specify what we need, and by doing so we can rely on the contract when we write our code. So the code above can actually use the DoIKnowThatICanDoThis() method on the value object without being worried that the “value” can be null. The contract between the users of the code and us writing the code, says that the “value” can’t be null.

Pre- and Postconditions

When working with DbC we are specifying pre- and postconditions. Precondition is a condition that should be met before a query or command is executed. An example of a precondition is: “The Value argument of the method can’t be null”, and we make sure the “value” isn’t null before the method is called. Postcondition is a condition that should be met when a command or query is completed, a postcondition will make sure the result is correct. An example of a postconditon is “The method will return a list with at least 1 item”.

Commands an Quires

When using DbC, we need to know what a Command and a Query is, because some principles that can be good to follow are based on commands and queries. A Command is something that will not return anything, like the SQL’s CREATE, UPDATE and DELETE.

There are two kinds of Commands when using DbC, the Creation commands (for example a Constructor), and Others. Others can for example be a Command to add a value to a list, remove or update a value etc.

//Creation commands

public Stack(int size)

//Other commands

public void Push(object value);

public void Remove();

A Query, is something that will return something, for example an Attribute, Property or a Function, like the SQL’s SELECT.

There are two kinds of Queries, the Basic Queries (Quires that aren’t based on another queries), and the Derived Queries, queries that is based on another queries. Here is an example of queries of a Stack:

//Basic Queries
        
public int Count;

public object this[int index] { get; }

//Derived Queries

//Is related to Count Query
public bool IsEmpty()
{
      return Count == 0;
}

To understand about some principles that are good to follow when using DbC, we need to know about the Commands and different Queries.

The 6 Principles

When working with DbC, it’s advisable to follow some principles to make it easier to define and use contracts. The following DbC principles are:

Separate commands and queries.
Separate basic queries from derived queries.
For each derived query, write a postcondition that specifies what result will be returned, in terms of one or more basic queries.
For each command, write a postcondition that specifies the value of every basic query.
For every query and command, decide on a suitable precondition.
Write invariants to define unchanging properties of objects.

Before I will write about each of them I want you to now that I’m going to use .Net 4.0 Code Contract. I will in the rest of the post uses a simple Stack (Yes I know, .Net already have a Stack class) to give you the basic understanding about using DbC. A Stack is a data structure where the last item in, will be the first item out. Here is a basic implementation of a Stack where not contract is specified yet:

public class Stack
{
    private object[] _array;

    //Basic Queries
    
    public uint Count;

    public object this[uint index]
    {
      get { return _array[index]; }
      set { _array[index] = value; }
    }

    //Derived Queries

    //Is related to Count Query
    public bool IsEmpty()
    {
      return Count == 0;
    }

    //Is related to Count and this[] Query
    public object Top()
    {
      return this[Count];
    }

    //Creation commands

    public Stack(uint size)
    {
       Count = 0;
       _array = new object[size];
    }

    //Other commands

    public void Push(object value)
    {
      this[++Count] = value;
    }

    public void Remove()
    {
      this[Count] = null;
      Count--;
    }
}

Note: The Stack is implemented in a way to demonstrate the use of Code Contract in a simple way, the implementation may not look like how you would implement it, so don’t think this is the perfect Stack implementation, only used for demonstration.

Before I will go deeper into the principles I will simply mention how we can use the .Net Code Contract.

I mention before about pre- and postcondition, is about “Require” something and to “Ensure” something. When using Code Contract, we will use a static class called “Contract” and is located in he “System.Diagnostics.Contracts” namespace. The contract must be specified at the top or our member statement block. To specify a precondition with Code Contract we uses the Contract.Requires method, and to specify a postcondition, we uses the Contract.Ensure method. Here is an example where both a pre- and postcondition are used:

public object Top()
{
     Contract.Requires(Count > 0, "Stack is empty");
     Contract.Ensures(Contract.Result<object>() == this[Count]);

     return this[Count];
}

The contract above requires that the Count is greater than 0, if not we can’t get the item at the Top of a Stack. We also Ensures that the results (By using the Contract.Result method, we can specify a postcondition that will check if the value returned from a method is correct) of the Top query is equal to this[Count].

1. Separate Commands and Queries

When working with DbC, it’s important to separate Command and Quires. A method should either be a command that performs an Action, or returning information to the caller, not both. By asking a question the answer shouldn’t be changed. The following is an example of a Command and a Query of a Stack:

public void Push(object value)

public object Top()

The Push is a command and will not return anything, just add a value to the Stack, the Top is a query to get the item at the top of the stack.

2. Separate basic queries from derived queries

There are two different kinds of queries, the basic queries that doesn’t rely on another queries, and derived queries that uses a basic query. The “Separate basic queries from derived queries” principle is about about that derived queries can be specified in terms of basic queries. So this principles is more about recognizing that a query is a derived query or a basic query. It will then make is much easier to follow the other principles. The following code shows a basic query and a derived query:

//Basic Queries
        
public uint Count;

//Derived Queries

//Is related to Count Query
public bool IsEmpty()
{
      return Count == 0;
}

We can see that IsEmpty will use the Count query, and that makes the IsEmpty a Derived query.

3. For each derived query, write a postcondition that specifies what result will be returned, in terms of one or more basic queries.

When the derived query is recognize we can follow the 3ed principle. For each derived query, we can create a postcondition that specifies what result our derived query will return in terms of one or more basic queries. Remember that DbC is about contracts between the users of the code and us writing the code. So we can’t use demand that the users will pass in a valid value, we must also ensure that we will give the users what the users wants, when the user is following our contract. The IsEmpty query of the Stack will use a Count query and that will make the IsEmpty a Derived query, so we should now write a postcondition that specified what results will be returned, in terms of using a basic query and in this case the Count query,

//Basic Queries
        
public uint Count;

//Derived Queries

public bool IsEmpty()
{
    Contract.Ensures(Contract.Result<bool>() == (Count == 0));

    return Count == 0;
}

The Contract.Ensures is used to create a postcondition. The above code will make sure that the results of the IsEmpty (by using the Contract.Result to get the result of the IsEmpty method) is correct, that will say that the IsEmpty will be either true or false based on Count is equal to 0 or not. The postcondition are using a basic query, so the IsEmpty is now following the 3ed principle. We also have another Derived Query, the Top query, it will also need a postcondition and it uses all basic queries. The Result of the Top method must be the same value as the this[] query returns.

//Basic Queries

public uint Count;

public object this[uint index]
{
     get  { return _array[index]; }
     set  { _array[index] = value; }
}

//Derived Queries

//Is related to Count and this[] Query
public object Top()
{
     Contract.Ensures(Contract.Result<object>() == this[Count]);

      return this[Count];
}

4. For each command, write a postcondition that specifies the value of every basic query.

For each command we will create a postconditon that specifies the value of basic queries. If we look at the Stack implementation we will have three Commands, one Creation command, the Constructor, and two others commands, Push and Remove. Those commands need a postcondition and they should include basic query to follow the 4th principle.

//Creation commands

public Stack(uint size)
{
  Contract.Ensures(Count == 0);
            
  Count = 0;
  _array = new object[size];
}

//Other commands

public void Push(object value)
{
   Contract.Ensures(Count == Contract.OldValue<uint>(Count) + 1);
   Contract.Ensures(this[Count] == value);

   this[++Count] = value;
}

public void Remove()
{
   Contract.Ensures(Count == Contract.OldValue<uint>(Count) - 1);

   this[Count] = null;

   Count--;
}

As you can see the Create command will Ensures that Count will be 0 when the Stack is created, when a Stack is created there shouldn’t be any items in the stack. The Push command will take a value and put it into the Stack, when an item is pushed into the Stack, the Count need to be increased to know the number of items added to the Stack, and we must also make sure the item is really added to the Stack. The postconditon of the Push method will make sure the that old value of the Count (by using the Contract.OldValue we can get the value a Query has before the method is called) plus 1 will be equal to the Count query, this is the way we can ensure that the Push will increase the Count with one. We also make sure the this[] query will now contain the item we pushed into the Stack. The Remove method must make sure the Count is decreased by one when the top item is removed from the Stack. The Commands is now following the 4th principle, where each command now have a postcondition that used the value of basic queries.

Note: The principle says every basic Query, the Remove only used one Query the Count, it’s because this command can’t use the this[] query because an item is removed, so the only way to make sure an item is removed is to just use the Count query, so the Remove will still follow the principle.

5. For every query and command, decide on a suitable precondition.

We have now focused only on postcondition, now time for some preconditons. The 5th principle is about deciding a suitable preconditon for every query and command. If we starts to look at one of our basic queries (will not go through all Queries and commands here, just some of them) the this[] query, we can’t pass an index that is lower then 1 (.Net arrays and list are zero based, but not the stack in this blog post ;)) and the index can’t be lesser than the number of items in the stack. So here we will need a preconditon.

public object this[uint index]
{
     get
     {
         Contract.Requires(index >= 1);
         Contract.Requires(index <= Count);

          return _array[index];
      }
}

Think about the Contract as an documentation about how to use the code in a correct way, so if the contract could be specified elsewhere (not part of the method body), we could simply write “return _array[index]” and there is no need to check if index is greater or lesser than Count, because that is specified in a “contract”. The implementation of Code Contract, requires that the contract is specified in the code. As a developer I would rather have this contract elsewhere (Like Spec#) or implemented in a way Eiffel uses it as part of the language.

Now when we have looked at one Query, we can also look at one command, the Remove command (You can see the whole implementation of the Stack at the end of this blog post, where precondition is added to more queries and commands then what I’m going to show in this section). We can only Remove an item if the Count is greater than 0. So we can write a precondition that will require that Count must be greater than 0.

public void Remove()
{
   Contract.Requires(Count > 0);
   Contract.Ensures(Count == Contract.OldValue<uint>(Count) - 1);

   this[Count] = null;
   Count--;
}

6. Write invariants to define unchanging properties of objects.

The last principle is about making sure the object are feeling great! This is done by using invariants. When using Code Contract we can specify invariants by adding a method with the attribute ContractInvariantMethod, the method must be private or public and can only contains calls to Contract.Invariant. To make sure the Stack feels great, the Stack must have 0 or more items, the Count can’t never be a negative value to make sure each command and queries can be used of the Stack. Here is our invariant for the Stack object:


[ContractInvariantMethod]
private void ObjectInvariant()
{
     Contract.Invariant(Count >= 0);
}

Note: The ObjectInvariant method will be called every time after a Query or Commands is called.

Here is the full example using Code Contract:

public class Stack
{
   private object[] _array;

   //Basic Queries

   public uint Count;

   public object this[uint index]
   {
     get
     {
        Contract.Requires(index >= 1);
        Contract.Requires(index <= Count);


        return _array[index];
     }
     set
     {
        Contract.Requires(index >= 1);
        Contract.Requires(index <= Count);
                
        _array[index] = value;
     }
   }

   //Derived Queries

   //Is related to Count Query
   public bool IsEmpty()
   {
      Contract.Ensures(Contract.Result<bool>() == (Count == 0));

      return Count == 0;
   }

   //Is related to Count and this[] Query
   public object Top()
   {
      Contract.Requires(Count > 0, "Stack is empty");
      Contract.Ensures(Contract.Result<object>() == this[Count]);

      return this[Count];
   }
        
   //Creation commands

   public Stack(uint size)
   {
      Contract.Requires(size > 0);
      Contract.Ensures(Count == 0);
            
      Count = 0;
      _array = new object[size];
   }

   //Other commands

   public void Push(object value)
   {
      Contract.Requires(value != null);
      Contract.Ensures(Count == Contract.OldValue<uint>(Count) + 1);
      Contract.Ensures(this[Count] == value);

      this[++Count] = value;
   }

   public void Remove()
   {
     Contract.Requires(Count > 0);
     Contract.Ensures(Count == Contract.OldValue<uint>(Count) - 1);

     this[Count] = null;

     Count--;
  }

  [ContractInvariantMethod]
  private void ObjectInvariant()
  {
    Contract.Invariant(Count >= 0);
  }
        
}

Summary

By using Design By Contract we can make sure the users are using our code in a correct way, and we must also make sure the users will get the expected results when they uses our code. This can be done by specifying contracts. To make it easy to use Design By Contract, some principles may be good to follow like the separation of commands an queries. With .Net 4.0 we can use the Code Contract feature to specify contracts.

Why should I need to waste so many resources and 1-3 minutes to get started?

2010-05-22T04:42:00Z

Every time I start my computer, I do the following:

Start messenger,TweetDeck, Spotify, (most of the time a Web Browser) and then Visual Studio 2010 to do some work.

4/5 are tools with a connection to the cloud (well 5/5 if the Start Page of VS2010 counts ;). So I’m actually only need access to the cloud and some tools to work with. I use Spotify to play music, music sent to me over the wire from the cloud, TweetDeck so see and send messages over the cloud, Messenger to keep contact with my friends and send messages over the cloud, a browser to get information located on the cloud.. Visual Studio 2010 to build apps for the cloud ;)

I put my working project also in the cloud to get access to it from any places, I use Dropbox to store some documents, I use a NAS that is connected to the cloud to I can get access any of my files through the cloud. I’m in and on the cloud most of my time.

What I need is a screen, a internet connection and a simple tool to get access to my hard drive for local storage, tools connected to the cloud. Why should I need to wait 1-3 minutes and waste about 1 gig of space just to see a boring loading screen of the OS too just use simple apps that will bring me into the cloud? Why use so many resources for such simple tasks? If I need to create a presentation, write a document etc, I can use tools located in the cloud, so what I only need is a OS that can connect me to the cloud and a “browser” to get access to the tools I need. The browser could be my OS!

Look at iPhone, a very nice UI, just show me some buttons with my apps, easy to access the apps I want and easy to use. The best part, it’s in a little box and it’s quite (when no people calls me ;)). The following is a simple UI, I could live with a UI like this to just do my work:

It’s simple, it’s in a little box, it gives me the basic information I need (most of the information is gathered from the cloud). I could easy press an image and open the program I want to use, and they could be located in the cloud. For example, Spotify. It’s like a browser, it only gather information from the cloud and show it on the screen. The app could easily be created so I could access it though a web browser, or as small as it’s on the iPhone (and how much resources is needed to just use Spotify on my iPhone?).

When I turn my computer on every day, and look at my desktop after spending some loading times, I just feel that my computer is heavy. Something makes it heavy.. I want to see something new, I want to see a light weight OS, a simple OS that doesn’t takes to much time to load just to get started.. how long can it take for a computer so just show some images?

Just a thought!

Use Extension method to write cleaner code

2010-05-09T09:09:00Z

This blog post will show you step by step to refactoring some code to be more readable (at least what I think). Patrik Löwnedahl gave me some of the ideas when we where talking about making code much cleaner.

The following is an simple application that will have a list of movies (Normal and Transfer). The task of the application is to calculate the total sum of each movie and also display the price of each movie.

class Program
{    
    enum MovieType
    {
        Normal,
        Transfer
    }

    static void Main(string[] args)
    {
        var movies = GetMovies();

        int totalPriceOfNormalMovie = 0;
        int totalPriceOfTransferMovie = 0;

        foreach (var movie in movies)
        {
            if (movie == MovieType.Normal)
           {
               totalPriceOfNormalMovie += 2;
               Console.WriteLine("$2");
            }
            else if (movie == MovieType.Transfer)
            {
                totalPriceOfTransferMovie += 3;
                Console.WriteLine("$3");
             }
         }
     }

     private static IEnumerable<MovieType> GetMovies()
     {
         return new List<MovieType>()
                             {
                                 MovieType.Normal,
                                 MovieType.Transfer,
                                 MovieType.Normal
                             };
     }
}

In the code above I’m using an enum, a good way to add types (isn’t it ;)). I also use one foreach loop to calculate the price, the loop has a condition statement to check what kind of movie is added to the list of movies. I want to reuse the foreach only to increase performance and let it do two things (isn’t that smart of me?! ;)).

First of all I can admit, I’m not a big fan of enum. Enum often results in ugly condition statements and can be hard to maintain (if a new type is added we need to check all the code in our app to see if we use the enum somewhere else). I don’t often care about pre-optimizations when it comes to write code (of course I have performance in mind). I rather prefer to use two foreach to let them do one things instead of two. So based on what I don’t like and Martin Fowler’s Refactoring catalog, I’m going to refactoring this code to what I will call a more elegant and cleaner code.

First of all I’m going to use Split Loop to make sure the foreach will do one thing not two, it will results in two foreach (Don’t care about performance here, if the results will results in bad performance, you can refactoring later, but computers are so fast to day, so iterating through a list is not often so time consuming.)

Note: The foreach actually do four things, will come to is later.

var movies = GetMovies();

int totalPriceOfNormalMovie = 0;
int totalPriceOfTransferMovie = 0;

foreach (var movie in movies)
{
    if (movie == MovieType.Normal)
    {
       totalPriceOfNormalMovie += 2;
       Console.WriteLine("$2");
    }
}

foreach (var movie in movies)
{
    if (movie == MovieType.Transfer)
    {
        totalPriceOfTransferMovie += 3;
        Console.WriteLine("$3");
     }
}

To remove the condition statement we can use the Where extension method added to the IEnumerable<T> and is located in the System.Linq namespace:

foreach (var movie in movies.Where( m => m == MovieType.Normal))
{
    totalPriceOfNormalMovie += 2;
    Console.WriteLine("$2");
}

foreach (var movie in movies.Where( m => m == MovieType.Transfer))
{
    totalPriceOfTransferMovie += 3;
    Console.WriteLine("$3");
}

The above code will still do two things, calculate the total price, and display the price of the movie. I will not take care of it at the moment, instead I will focus on the enum and try to remove them. One way to remove enum is by using the Replace Conditional with Polymorphism. So I will create two classes, one base class called Movie, and one called MovieTransfer. The Movie class will have a property called Price, the Movie will now hold the price:

public class Movie
{
    public virtual int Price
    {
        get { return 2; }
    }
}


public class MovieTransfer : Movie
{
    public override int Price
    {
       get { return 3; }
    }
}

The following code has no enum and will use the new Movie classes instead:

class Program
{    
   static void Main(string[] args)
   {
       var movies = GetMovies();

       int totalPriceOfNormalMovie = 0;
       int totalPriceOfTransferMovie = 0;

       foreach (var movie in movies.Where( m => !(m is MovieTransfer)))
       {
          totalPriceOfNormalMovie += movie.Price;
          Console.WriteLine(movie.Price);
       }

       foreach (var movie in movies.Where( m => m is MovieTransfer))
       {
         totalPriceOfTransferMovie += movie.Price;
         Console.WriteLine(movie.Price);
       }
     }

     private static IEnumerable<Movie> GetMovies()
     {
         return new List<Movie>()
                            {
                                 new Movie(),
                                 new MovieTransfer(),
                                 new Movie()
                             };
     }
}

If you take a look at the foreach now, you can see it still actually do two things, calculate the price and display the price. We can do some more refactoring here by using the Sum extension method to calculate the total price of the movies:

static void Main(string[] args)
{
    var movies = GetMovies();

     int totalPriceOfNormalMovie = movies.Where(m => !(m is MovieTransfer))
                                         .Sum(m => m.Price);

     int totalPriceOfTransferMovie = movies.Where(m => m is MovieTransfer)
                                           .Sum(m => m.Price);
            
     foreach (var movie in movies.Where( m => !(m is MovieTransfer)))
           Console.WriteLine(movie.Price);

     foreach (var movie in movies.Where( m => m is MovieTransfer))
           Console.WriteLine(movie.Price);
}

Now when the Movie object will hold the price, there is no need to use two separate foreach to display the price of the movies in the list, so we can use only one instead:

foreach (var movie in movies)
     Console.WriteLine(movie.Price);

If we want to increase the Maintainability index we can use the Extract Method to move the Sum of the prices into two separate methods. The name of the method will explain what we are doing:

static void Main(string[] args)
{
    var movies = GetMovies();

    int totalPriceOfMovie = TotalPriceOfMovie(movies);

    int totalPriceOfTransferMovie = TotalPriceOfMovieTransfer(movies);
            
    foreach (var movie in movies)
        Console.WriteLine(movie.Price);

}

private static int TotalPriceOfMovieTransfer(IEnumerable<Movie> movies)
{
    return movies.Where(m => m is MovieTransfer)
                 .Sum(m => m.Price);
}

private static int TotalPriceOfMovie(IEnumerable<Movie> movies)
{
    return  movies.Where(m => !(m is MovieTransfer))
                  .Sum(m => m.Price);
}

Now to the last thing, I love the ForEach method of the List<T>, but the IEnumerable<T> doesn’t have it, so I created my own ForEach extension, here is the code of the ForEach extension method:

public static class LoopExtensions
{
   public static void ForEach<T>(this IEnumerable<T> values, Action<T> action)
   {
       Contract.Requires(values != null);
       Contract.Requires(action != null);

       foreach (var v in values)
           action(v);
   }
}

I will now replace the foreach by using this ForEach method:

static void Main(string[] args)
{
    var movies = GetMovies();

     int totalPriceOfMovie = TotalPriceOfMovie(movies);

     int totalPriceOfTransferMovie = TotalPriceOfMovieTransfer(movies);

     movies.ForEach(m => Console.WriteLine(m.Price));
}

The ForEach on the movies will now display the price of the movie, but maybe we want to display the name of the movie etc, so we can use Extract Method by moving the lamdba expression into a method instead, and let the method explains what we are displaying:


movies.ForEach(DisplayMovieInfo);


private static void DisplayMovieInfo(Movie movie)
{
     Console.WriteLine(movie.Price);
}

Now the refactoring is done, or?

EDIT: It's not done. Niclas Nilsson wrote a good comment that I actually do two things in the TotalPrice... methods, a filtering and a Sum. So both a command and a query. so it will not follow the Command and Query Principle. To make the code more seperated by concerns:

The TotalPriceXXX method are removed and replaced with on called TotalPriceOfMovie. Two properties are added, one for returning the normal movies and one for returning the transfer movies. Here is the result of the new refactoring:

static void Main(string[] args)
{
    int totalPriceOfMovie = TotalPriceOfMovie(NormalMovies);

    int totalPriceOfTransferMovie = TotalPriceOfMovie(MovieTransfers);
            
    foreach (var movie in movies)
        Console.WriteLine(movie.Price);

}

private static int TotalPriceOfMovie(IEnumerable<Movie> movies)
{
    return movies.Sum(m => m.Price);
}

private static IEnumerable<Movie> NormalMovies
{
    get { return AllMovies.Where(m => !(m is MovieTransfer)); }
}

private static IEnumerable<Movie> MovieTransfers

{
    get { return AllMovies.Where(m => m is MovieTransfer); }
}


private static IEnumerable<Movie> AllMovies

{
    get { return GetAllMovies(); }
}

private static IEnumerable<Movie> GetMovies()
{
     return new List<Movie>()
                {
                  new Movie(),
                  new MovieTransfer(),
                  new Movie()
                };
}

Note: The GetMovies() method in this code is just a fake method to return fake data, so it could instead be a call to a Repository etc.

I think the new code is much cleaner than the first one, and I love the ForEach extension on the IEnumerable<T>, I can use it for different kind of things, for example:

movies.Where(m => m is Movie)
      .ForEach(DoSomething);

By using the Where and ForEach extension method, some if statements can be removed and will make the code much cleaner. But the beauty is in the eye of the beholder. What would you have done different, what do you think will make the first example in the blog post look much cleaner than my results, comments are welcome!

If you want to know when I will publish a new blog post, you can follow me on twitter: http://www.twitter.com/fredrikn