Lasse Eskildsen

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 4 and 5

lasseeskildsen — Sun, 16 Nov 2008 22:40:36 GMT

This post has been a couple of days on it's way. The reason for not posting it after each day is that there was not much new that you could not already find on almost every .net blog out there.

Thursday I attended a session on "Velocity", Microsoft's upcoming solution to distributed in-memory cache. This is pretty cool and straight forward (at least for the basic stuff). To demonstrate this, a member of the audience set up Velocity on two servers in a few minutes. This reminded me of the importance of the abstractions we normally use on various features. With a simple abstraction for caching, I really believe you could make the switch to Velocity in a day.

I also attended an XNA session. Before leaving home, I actually decided not to go to that kind of sessions, but as you might have guessed, I changed my mind. Game development is a really hardcore object oriented discipline, and my idea is that a good game developer makes a hardcore application developer, and the session gave a good idea on a completly different way of using objects, methods, loops and more. Pretty cool, if I ever get the time (I doubt it) I'll put my old XBOX 360 to good use with XNA :o)

Friday I attended a very cool session with Udi Dahan on architecture, how to make interfaces concrete, and how he and his team resolved some of their (architectural) issues. Pretty cool guy, and a very inspirering session. I really like the following slide. It's on why to make roles explicit using interfaces.

Final Impressions

It has definitely been a unique experience to participate in the conference, I cannot help but to feel kind of privileged to be working in a company that realises this! I have agreed to participate in a podcast by Søren about the general TechEd experience, so stay tuned.

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 :)

Performance Profiling And Commerce Server 2007

lasseeskildsen — Thu, 16 Oct 2008 21:43:21 GMT

Not too long ago we had to do some performance profiling for a Commerce Server site that went into production a couple of months before. We knew we had some performance issues, but because of some inventory issues at the client, we had to rush the site into production.

The first couple of days the performance was acceptable, but as more and more customers started hitting the site, some of the nasty issues we addressed started showing up. The site was stable though, just not the fastest one out there.

The site is a pretty standard e-commerce site, not much fancy stuff on this one. The only exception is some very large categories rendering 500+ products on a single page.

First Things First: HTML Ad Libitum

Generating HTML for a category containing 500+ can be pretty tough on both the server and the client side. On the server side, the basic category layout was built using a couple of ASP.NET user controls and each product view consisted of a couple of user controls too. This provided a very flexible and configurable layout, but the performance for generating all those server controls and related markup was pretty tough for the server. The HTML output (without images) was about ~1.6 MB, which the browser wasn't too happy about either.

So removing a lot of user controls and only one user control per product resulted in an HTML output around ~400 kb tops. No need to say that this had a major impact on performance.

With the HTML all nice and cleaned up, we can start digging in to the inner workings of the site.

Next up: Tracing For Bottlenecks

To get a basic idea of where bottlenecks could be found, we turned to the ASP.NET Output Trace. It's pretty simple stuff, and I wrote some stuff the trace we I knew we had some issues. When displaying categories we had to do a lot of heavy filtering on product variants. Each product having about 10+ variants, a product list with 500 products would generate ~5.000 products to filter!

However, the trace showed that this wasn't nearly as time consuming as I had imagined. A bigger problem was in a user controlle called CatalogTopMenu.ascx.

At the top of the site the user can navigate through the catalogs available in the catalog set, implemented in CatalogTopMenu.ascx.

Bring In The Profiler

Of course, you could add stuff to the trace, compile, deploy, test, check trace, write down result, remove trace code, add more trace code, compile, deploy and so on. Instead we used ANTS Profiler from Red Gate. I really love this tool, it fairly easy to use, but it provides some real useful result. If you find yourself in need of a performance profiler I can highly recommend trying this one - there's a 14-day free trial available on their web site.

Setting Up ANTS Profiler For Commerce Server

When profiling an ASP.NET site, ANTS Profiler starts a new instance of the worker process (w3wp.exe), which runs the site you're profiling. Because Commerce Server requires a seperate application pool, running the site outside IIS proved a bit difficult. The profiling worker process is being executed by a service called "ANTS Profiler 3 Server", so setting the log on identity for this one to the same identity as the application pool used to host the site resolved this issue. You can find the service under Control Panel > Administrative Tools > Services. Here's my setup:

Next up, start the profiler from the site, and browse around. When you're done browsing, hit the "Take Snapshop" button in the profiler.

The Profiler Results

The main window displays slowest lines of code (top) and slowest method (bottom):

Looking at the slowest method you can see it's a lot slower than the second slowest! Taking a look at the source method we find the following line, which is the sinner:

It kind of surprised me that the cause of our slowest methods is a call to the Commerce Server API. We did a lot of additional tests to prove this right, and they all confirmed this issue, even though catalogs are being cached. I would imagine it would have taken a lot of Trace.Writes to find this one.

Dllhost.exe Consuming A Lot Of Memory

As a side note, we had issues with the dllhost.exe service on the server would consume a lot of memory! After a short visit to Google, it turned out that there's a known memory leak in a COM+ component, causing the dllhost.exe to run wild when performing many catalog imports. We're using BizTalk to import a lot of products, so applying Commerce Server Service Pack 2 should resolve this issue.

The Results

Fixing the issues mentioned above had a major positive impact on the performance. Other thing we did was:

Improving the algorithm for filtering variants
Removed some unnessecary calls to the catalog and inventory system
A bit more caching
And a lot more

The server side generation went from ~25 seconds to ~4 seconds the the single heaviest page on the site. With the HTML being all slim, the rendering on the client side improved a lot too.

Next up is to open up Reflector and SQL Profiler to find out why getting a catalog is such a tough operation, and maybe do a blog post about it, unless Brian beats me to it...

Yet another .NET blogger in town

lasseeskildsen — Tue, 30 Sep 2008 20:23:36 GMT

Yes - another .NET related blog for the cloud!

At any point, a more personal page about me will appear somewhere on this site, but until then I guess a short introduction would be suiteable.

My name is Lasse and I am a .NET developer from Århus, Denmark. I work at a company called Vertica, where I primarily work with Microsoft Commerce Server, building custom enterprise e-commerce solutions. This blog will evolve around this, and include everything .NET related I stumble upon - problems, solutions and interesting stuff.