Lasse Eskildsen : .NET

Blog moved!

lasseeskildsen — Tue, 10 Nov 2009 20:19:00 GMT

I have moved my blog to http://blog.lasseeskildsen.net/ - stay tuned ;)

The asp.net attribute

lasseeskildsen — Tue, 28 Apr 2009 20:39:20 GMT

When deploying ASP.NET applications to a production environment, you will most likely want to set the compilation debug attribute in web.config to false, as having debug set to true has some downsides:

Compilation takes longer as batch optimizations are disabled
Scripts and images from WebResources.axd will not be cached on the client
Larger memory footprint
Code will execute slower because of enabled debug paths

To force debug = false in all ASP.NET applications on the server, you can change the retail switch in machine.config:

<system.web>

</system.web>

</configuration>

This will also disable page output trace and force custom error pages.

TechEd 2008 Podcast

lasseeskildsen — Tue, 02 Dec 2008 21:18:07 GMT

Not too long ago I did a podcast with Søren from Aarhus .NET Usergroup (ANUG) about my trip to TechEd in Barcelona. It's in Danish, and you can find it right here.

In august I did another podcast with Søren after my SubSonic presentation, and you can find that one right here, and the code and slides is one the site too.

Demystifying the Page_Load Method

lasseeskildsen — Thu, 20 Nov 2008 22:43:04 GMT

During a debugging session today Søren and I got to talk about how the Page_Load method on a page is called.

The method is called after the Load event and is declared like this:

        1: protected void Page_Load(object sender, EventArgs e)

       2: {

       3:     

       4: }

Taking a look at the Page class in Reflector shows the it inherits from the TemplateControl class. All the following code is extracted using Reflector.

If we take a look at the TemplateControl class we can see that following constants are declared:

       1: private const string _onTransactionAbortEventName = "OnTransactionAbort";

       2: private const string _onTransactionCommitEventName = "OnTransactionCommit";

       3: private const string _pageAbortTransactionEventName = "Page_AbortTransaction";

       4: private const string _pageCommitTransactionEventName = "Page_CommitTransaction";

       5: private const string _pageDataBindEventName = "Page_DataBind";

       6: private const string _pageErrorEventName = "Page_Error";

       7: private const string _pageInitCompleteEventName = "Page_InitComplete";

       8: private const string _pageInitEventName = "Page_Init";

       9: private const string _pageLoadCompleteEventName = "Page_LoadComplete";

      10: private const string _pageLoadEventName = "Page_Load";

      11: private const string _pagePreInitEventName = "Page_PreInit";

      12: private const string _pagePreLoadEventName = "Page_PreLoad";

      13: private const string _pagePreRenderCompleteEventName = "Page_PreRenderComplete";

      14: private const string _pagePreRenderEventName = "Page_PreRender";

      15: private const string _pageSaveStateCompleteEventName = "Page_SaveStateComplete";

      16: private const string _pageUnloadEventName = "Page_Unload";

Right there on line 10 you can the name of the Page_Load method declared. If you declare a method with the same signature as the default generated Page_Load method, but name them after the constants declared above they will automatically get called appropriately.

The reason why, is found in the HookUpAutomaticHandlers() method on the TemplateControl class which eventually calls the GetDelegateInformationFromMethod(string, IDictionary) method. The source looks something like this (please excuse the variable naming). Methods are listed in the order which they are called:

       1: internal void HookUpAutomaticHandlers()

       2: {

       3:     if (this.SupportAutoEvents)

       4:     {

       5:         object obj2 = _eventListCache[base.GetType()];

       6:         IDictionary dictionary = null;

       7:         if (obj2 == null)

       8:         {

       9:             lock (_lockObject)

            {

                obj2 = _eventListCache[base.GetType()];

                if (obj2 == null)

                {

                    dictionary = new ListDictionary();

                    this.GetDelegateInformation(dictionary);

                    if (dictionary.Count == 0)

                    {

                        obj2 = _emptyEventSingleton;

                    }

                    else

                    {

                        obj2 = dictionary;

                    }

                    _eventListCache[base.GetType()] = obj2;

                }

            }

        }

        if (obj2 != _emptyEventSingleton)

        {

            dictionary = (IDictionary) obj2;

            foreach (string str in dictionary.Keys)

            {

                EventMethodInfo info = (EventMethodInfo) dictionary[str];

                bool flag = false;

                MethodInfo methodInfo = info.MethodInfo;

                Delegate delegate2 = base.Events[_eventObjects[str]];

                if (delegate2 != null)

                {

                    foreach (Delegate delegate3 in delegate2.GetInvocationList())

                    {

                        if (delegate3.Method.Equals(methodInfo))

                        {

                            flag = true;

                            break;

                        }

                    }

                }

                if (!flag)

                {

                    IntPtr functionPointer = methodInfo.MethodHandle.GetFunctionPointer();

                    EventHandler handler = new CalliEventHandlerDelegateProxy(this, functionPointer, info.IsArgless).Handler;

                    base.Events.AddHandler(_eventObjects[str], handler);

                }

            }

        }

    }

}

  

private void GetDelegateInformation(IDictionary dictionary)

{

    if (HttpRuntime.IsFullTrust)

    {

        this.GetDelegateInformationWithNoAssert(dictionary);

    }

    else

    {

        this.GetDelegateInformationWithAssert(dictionary);

    }

}

  

private void GetDelegateInformationWithNoAssert(IDictionary dictionary)

{

    if (this is Page)

    {

        this.GetDelegateInformationFromMethod("Page_PreInit", dictionary);

        this.GetDelegateInformationFromMethod("Page_PreLoad", dictionary);

        this.GetDelegateInformationFromMethod("Page_LoadComplete", dictionary);

        this.GetDelegateInformationFromMethod("Page_PreRenderComplete", dictionary);

        this.GetDelegateInformationFromMethod("Page_InitComplete", dictionary);

        this.GetDelegateInformationFromMethod("Page_SaveStateComplete", dictionary);

    }

    this.GetDelegateInformationFromMethod("Page_Init", dictionary);

    this.GetDelegateInformationFromMethod("Page_Load", dictionary);

    this.GetDelegateInformationFromMethod("Page_DataBind", dictionary);

    this.GetDelegateInformationFromMethod("Page_PreRender", dictionary);

    this.GetDelegateInformationFromMethod("Page_Unload", dictionary);

    this.GetDelegateInformationFromMethod("Page_Error", dictionary);

    if (!this.GetDelegateInformationFromMethod("Page_AbortTransaction", dictionary))

    {

        this.GetDelegateInformationFromMethod("OnTransactionAbort", dictionary);

    }

    if (!this.GetDelegateInformationFromMethod("Page_CommitTransaction", dictionary))

    {

        this.GetDelegateInformationFromMethod("OnTransactionCommit", dictionary);

    }

}

  

private bool GetDelegateInformationFromMethod(string methodName, IDictionary dictionary)

{

    EventHandler handler = (EventHandler) Delegate.CreateDelegate(typeof(EventHandler), this, methodName, true, false);

    if (handler != null)

    {

        dictionary[methodName] = new EventMethodInfo(handler.Method, false);

        return true;

    }

    VoidMethod method = (VoidMethod) Delegate.CreateDelegate(typeof(VoidMethod), this, methodName, true, false);

    if (method != null)

    {

        dictionary[methodName] = new EventMethodInfo(method.Method, true);

        return true;

    }

    return false;

}

On line 15 the delegates are all collected into a dictionary using the GetDelegateInformationFromMethod method. On lines 31 to 53 the MethodInfos are collected, and handlers is added to the events collection. When raising the associated events (e.g. Load for the Page_Load method), the MethodInfo is invoked from the Events-collection.

The HookUpAutomaticHandlers method is called from the SetIntrinsics method on the Page class.

Summary

So to sum up, the Page_Load method and all it's colleagues (Page_Init, Page_DataBind etc.) are not invoked using slow reflection, but is simply grabbed as a named delegate. I'm not used to use these delegates, but from now on I don't see any reason why not to use them, instead of overriding the OnInit, OnPreRender etc. methods.

Well, nothing new in this one, just stuff thats makes me wonder :o)

Spec# To Be Replaced By Code Contracts?

lasseeskildsen — Sun, 16 Nov 2008 23:19:01 GMT

As you might have seen from a previous post I'm pretty excided on Spec# from Microsoft Research, so when my collegue Søren returned from PDC and he told me that Spec# would replaced by Code Contracts I felt kind of disappointed. However, having looked briefly at Code Contracts I must admit that it looks pretty cool. It is especially worth noticing that Code Contract seems to be working well with Pex. How cool would it be to be able to test your domain model with Pex! Because of this, the next articles on Spec# is put on hold, but will eventually continue as either Code Contracts or Spec# posts (actually hoping it's going to be Code Contracts).

I haven't been able to find more on this anywhere, so please do not just take my word for it. However, a couple of team members are both on the Spec# and the Code Contracts team. Feel free to drop a comment if you have more info on this!

TechEd 2008: Day 3

lasseeskildsen — Wed, 12 Nov 2008 21:43:28 GMT

Wow, a lot of cool stuff today!

Building custom Linq providers with Bart de Smet (B#) - cool!
"Web Scalability and Asynchronous Systems Architecture"
Deep reflection with Roy Osherove (from TypeMock), cool guy and a very cool session! Learned a lot about DynamicMethod, Reflection.Emit and IL!
Hardcore ASP.NET performance and memory debugging with Tess Ferrandez. This was really cool, something I definitely will be using, so expect some blogposts on this. Until then, take a look at Tess' blog and her BuggyBits lab.
Country drinks... 'Nuff said...

TechEd 2008: Day 2

lasseeskildsen — Tue, 11 Nov 2008 19:41:24 GMT

Today I attended an introduction to "Oslo", "Dublin" and WF 4.0, Commerce Server "Mojave", ASP.NET MVC basics, ASP.NET MVC tech deep dive, data centric web applications and a very abstract architectural session.

There's really not much to blog about as the web is already full of MVC stuff, which were the most exciting part of the day. Until today I have been somewhat sceptic of ASP.NET MVC as it left me with the same feeling as when I did ASP Classic some years ago.

Today that changed! Jonathan Carter and Hadi Hariri gave some cool presentations showing a lot of nice features. In the last session, Hadi talked about how to customize the various parts of ASP.NET MVC, from controller factories using IoC to implementing custom filters (and a lot more!).

Well, not much to blog about, this post is most to let my colleagues know I'm still alive :-)

Tomorrow is about some more advanced ASP.NET stuff, debugging and performance profiling, and last but definitely not least: Country drinks :-)

TechEd 2008: Day 1

lasseeskildsen — Mon, 10 Nov 2008 20:47:00 GMT

So the first "real" day of TechEd is over, and here's some of the things that really impressed me today.

The keynote and "Camano"

Jason Zander gave the keynote, where he showed a lot of the new features of Visual Studio 2010. One thing that was really cool was the "Camano" project. Camano is "just" an application which you connect to your team project in TFS. Testers can then use the software to go through test cases and approve or disapprove a test case. If a test case is disapproved, the tester can submit it as a bug to TFS. This is really cool, because Camano includes screen capture, so the steps to reproduce is recorded as a video in .wmv format. Furthermore, the application's state is captured too, so you can actually debug the application in Visual Studio using the exact state as when the bug occured! In addition, if virtual machines are used for testing, it can recreate the entire state of multiple machines as when the bug appeared. Now we devs have to come up with something else than "it works on my computer" :-)

This is just one feature of Camona, it includes a lot more nice features - can't wait to get my hands on it!

Commerce Server "Mojave"

At the welcome reception after today's sessions, I ran in the Ryan Donovan and Scott Cairney. They gave a live demonstration of the upcomming Commerce Server release, code named "Mojave". Long story short, the next release contains a brand new sleek API, a pure non-COM .NET alternative to pipelines and comes with a very nice SharePoint integration. Furthermore, they demoed the new Silverlight based web tools where they showed live editing of products and variants using the Silverlight based tools - can't wait to try it out! The screenshot below (well, not so much screenshot as "shot-of-a-screen-taken-with-my-mobile") shows the new Starter Site running in SharePoint edit mode.

The first CTP is available for download, the next CTP is released in a few weeks, and the final release is scheduled for Q1 2009. Looking forward to it!

Apart from the keynote and the reception I attended an architecture session, as well as a IronPython and IronRuby session - nice stuff too!

TechEd 2008: Day 0

lasseeskildsen — Sun, 09 Nov 2008 20:44:00 GMT

Today I arrived at Barcelona to attend TechEd for developers next week. After some waiting, some flight, a little more waiting, a little more flight, and an overly excited Spanish taxi driver I arrived at the hotel, which turned out to be pretty nice!

Upon the registration at the conference center, I got my TechEd swag bag, and here's what it contains:

Take a look at the close up of the geeky t-shirt:

Thank you Microsoft :-)

Enforcing Your Domain Model With Spec#: Part 1: Introduction And The Non-Null Operator

lasseeskildsen — Thu, 30 Oct 2008 21:35:09 GMT

I'm a huge fan of Domain Driven Design (DDD) (links here, here and here) and this post is the first in many, all about enforcing your domain model using Spec#.

So What Is Spec#?

Spec# is a super set of C# 2.0 (no, unfortunately not 3.0 yet). This means that Spec# has all the features as C#, and all the Spec# stuff on top of that.

Spec# is about specifying, and because the guys at Microsoft probably explains it better than I do, I have ~~stolen~~ copied this from the Spec# web site:

The Spec# programming language. Spec# is an extension of the object-oriented language C#. It extends the type system to include non-null types and checked exceptions. It provides method contracts in the form of pre- and postconditions as well as object invariants.

The Spec# compiler. Integrated into the Microsoft Visual Studio development environment for the .NET platform, the compiler statically enforces non-null types, emits run-time checks for method contracts and invariants, and records the contracts as metadata for consumption by downstream tools.

The Spec# static program verifier. This component (codenamed Boogie) generates logical verification conditions from a Spec# program. Internally, it uses an automatic theorem prover that analyzes the verification conditions to prove the correctness of the program or find errors in it.

This first post explains the non-null operator, so let's get to it.

The Non-Null Operator

The non-null operator is probably the most simple operator in Spec#, yet I find it very effecient to express e.g. value objects or aggregates in the domain.

The non-null operator is in a way the opposite as the nullable operator in C#, which allows value types to be nullable. The non-null operator allows you to specify reference types as being non-nullable by using an exclamation mark (!).

The C# way:

        1: public string Foo(object o)

       2: {

       3:     return o.ToString(); // NullReferenceException

       4: }

       5:  

       6: public void Bar()

       7: {

       8:     object o = null;

       9:     string str = Foo(o);

      10: }

The Spec# way:

       1: public string Foo(object! o)

       2: {

       3:     return o.ToString();

       4: }

       5:  

       6: public void BadBar()

       7: {

       8:     object o = null;

       9:     string str = Foo(o); // Spec# warning

      10: }

      11:  

      12: public void GoodBar()

      13: {

      14:     object o = null;

      15:  

      16:     if (o != null) // We're ok

      17:         Foo(o); 

      18: }

If o was initialized to something else than null in GoodBar() the Spec# compiler would be happy too.

In a domain example an implementation could be something like this:

       1: public class OrderLineItem

       2: {

       3:     ...

       4:  

       5:     // We're making the product property non-nullable as an order line item without a product

       6:     // does not make much sense, it would just be a quantity of nothing.

       7:     public IProduct! Product

       8:     {

       9:         get; private set; 

    }

  

    public int Quantity

    {

        get; set;

    }

  

    ...

}

  

public class PurchaseOrder

{

    ...

  

    public OrderLineItem AddProduct(IProduct! product, int quantity)

    {

        // Add product - no need to check for null

    }

  

    ...

}

  

public class Cart

{

    public void Add(IProduct product)

    {

        if (product != null)

            PurchaseOrder.AddProduct(product, 1);

        else

            // Handle null product        

    }

}

In the example above, the caller of PurchaseOrder.AddProduct is forced to check for null before calling the method. This really encapsulates clean business logic in the PurchaseOrder and OrderLineItem classes. In C# you would create a guard clause at the top of the AddProduct method, but in order for a developer to know about this, he has to read the implementation of the method. By using Spec# the developer is made aware of this when calling the method.

Please feel free the leave a comment or contact me of you have any questions or comments!

Part 2 is all about preconditions... Coming up!

Got Source Control?

lasseeskildsen — Sun, 19 Oct 2008 17:59:00 GMT

If you're a small team or a single person and find the need for some source control and backup, I can highly recommend ProjectLocker. It includes Trac for management, and BuildLocker can be added for CI. The uptime is amazing too! I use the VisualSVN client for Visual Studio along with TortoiseSVN, but it supports most tools.

I use the lowest service level which includes unlimited repositories, 1 GB space and 2 users - the price is $2.50 pr month.

And no, I don't get any royalties :)