life in the so called space age

Currying The ASP.NET Cache

noreply@blogger.com (Steve J Rodgers) — Sat, 21 Mar 2009 16:41:00 +0000

I’m reposting this blog entry with code in lieu of images after Ian sent me a rant email quite rightly complaining that he couldn’t read the code in the images (apologies to Ian and anyone else who reads this blog!)

<snip/>

The ASP.NET cache is a thing of beauty. But one thing that fills me with dread whenever I see it is an application littered with ASP.NET caching access code.
One of the other issues that developers have to handle is the possibility that stuff you put in it may not be there next time you ask for it back because the cache is prone to being purged when memory is constrained. This can lead to hideous looking developer code like this:

public void Page_Load(object sender, EventArgs args)
{
Person p = (Person)Cache["human"];

        if (p == null)
        {
            p = HumanBusinessLogic.GetPerson(Request["id"]);
            Cache["human"] = p;
        }
        // go ahead and use p
}

Yuck!!
To clean up the mess with a little refactoring, we could at least put the cache code in the business logic:

public static Person GetPerson(string id)
{
Cache cache = HttpContext.Current.Cache;

Person p = (Person)cache["human"];

        if (p == null)
        {
            p = HumanDataAccess.GetPerson(id);
            cache["human"] = p;
        }

return p;
}

But the problem now comes that for every business method that uses caching, there will be a cut and paste of the exact same code plus marginal refactor. The solution to that issue might lead us to develop a base class that offers up some kind of caching method that all business logic classes can then derive from and gain benefit.
This base class method would need to solve a couple of scenarios for it to be of any use to a derived class. First, it must look in the cache to see if the item is there and return it if it is. Second, it should have a mechanism of getting the item from the database and repopulating the cache if the item is not in the cache. The first scenario is a breeze, but the second scenario could be problematic. For example, most business logic entities come from a data access method invocation, but how many parameters will the data access method need and what types will they be?

A first crack at solving the problem might be to pretend that the data access method takes no parameters. That way, we could pass a delegate as a parameter that is invoked by the cache code when it detects a cache miss. The code would look like this (and notice the delegate takes no parameters)

public delegate DataTable RetrieveData();

public class CurriedCache
{
    public static DataTable getCachedDataItem(string cacheKey,
                                                        RetrieveData retriever)
    {
        Cache cache = HttpRuntime.Cache;
        DataTable item = (DataTable)cache[cacheKey];
        if (item == null)
        {
            lock (typeof(CurriedCache))
            {
                item = (DataTable)cache[cacheKey];
                if (item == null)
                {
                    item = retriever();
                    cache.Add(cacheKey,
                                item,
                                null,
                                Cache.NoAbsoluteExpiration,
                                Cache.NoSlidingExpiration,
                                CacheItemPriority.Default,
                                null);
                }
            }
        }

return item;
}
}

There are some huge issues with this implementation. First of all, it is assumed that the item being stored is a DataTable. Second, there is still the assumption that the retriever function takes no parameters.

To solve the first problem, we can use generics:

public delegate TResult RetrieveData<TResult>();

public class CurriedCache
{
    public static TResult getCachedDataItem<TResult>(
string cacheKey,
RetrieveData<TResult> retriever)
        where TResult : class
    {
        Cache cache = HttpRuntime.Cache;
        TResult item = (TResult)cache[cacheKey];
        if (item == null)
        {
            lock (typeof(CurriedCache))
            {
                item = (TResult)cache[cacheKey];
                if (item == null)
                {
                    item = retriever();
                    cache.Add(cacheKey,
                                item,
                                null,
                                Cache.NoAbsoluteExpiration,
                                Cache.NoSlidingExpiration,
                                CacheItemPriority.Default,
                                null);
                }
            }
        }

return item;
}
}

A useful bit of tidy up would be to replace the RetrieveData delegate with the Func<TResult> delegate that Microsoft already define as part of a family of delegates called Func that take no arguments, one argument, two arguments, etc respectively.

namespace System
{
    public delegate TResult Func<TResult>();
    public delegate TResult Func<T, TResult>(T arg);
    public delegate TResult Func<T, TResult>(T arg);
    public delegate TResult Func<T1, T2, TResult>(T1 arg1,
                                                                        T2 arg2);
    public delegate TResult Func<T1, T2, T3, TResult>(T1 arg1,
                                                                    T2 arg2, T3 arg3);
    public delegate TResult Func<T1, T2, T3, T4, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);
}

It’s almost done, but not quite. There is still the serious limitation of the retriever function taking no parameters. The solution involves a bit of currying. We will also define overloaded versions of the getCachedDataItem to cater for retriever functions that expect more than one parameter:

public class CurriedCache
{
    public static TResult getCachedDataItem<TResult>(
                                                        string cacheKey,
                                                        object monitor,
                                                        DateTime absoluteExpiration,
                                                        TimeSpan slidingExpiration,
                                                        Func<TResult> retriever)
        where TResult : class
    {
        Cache cache = HttpRuntime.Cache;
        TResult item = (TResult)cache[cacheKey];
        if (item == null)
        {
            lock (monitor)
            {
                item = (TResult)cache[cacheKey];
                if (item == null)
                {
                    item = retriever();
                    cache.Add(cacheKey,
                                item,
                                null,
                                absoluteExpiration,
                                slidingExpiration,
                                CacheItemPriority.Default,
                                null);
                }
            }
        }

return item;
}

    public static TResult getCachedDataItem<T1, TResult>(
                                                        string cacheKey,
                                                        object monitor,
                                                        DateTime absoluteExpiration,
                                                        TimeSpan slidingExpiration,
                                                        Func<T1, TResult> retriever,
                                                        T1 a)
        where TResult : class
    {
        return getCachedDataItem<TResult>(cacheKey,
                                            monitor,
                                            absoluteExpiration,
                                            slidingExpiration,
                                            () => { return retriever(a); });
    }

    public static TResult getCachedDataItem<T1, T2, TResult>(
                                                        string cacheKey,
                                                        object monitor,
                                                        DateTime absoluteExpiration,
                                                        TimeSpan slidingExpiration,
                                                        Func<T1, T2, TResult> retriever,
                                                        T1 a,
                                                        T2 b)
        where TResult : class
    {
        return getCachedDataItem<TResult>(cacheKey,
                                            monitor,
                                            absoluteExpiration,
                                            slidingExpiration,
                                            () => { return retriever(a, b); });
    }
}

Notice how the overloaded versions expect the retriever function to be a delegate that takes one or more arguments and notice how this delegate is then invoked in a wrapped delegate of the first type (Func<TResult>)
Since it’s likely we want to be able to lock cached items independently, it probably makes sense to introduce a lock parameter for finer grained locking. The addition of absolute and sliding expiration parameters also give a degree of finer control over caching behavior. The final tidy up also uses lamda expression syntax to invoke the delegates.

How to actively highlight a GridView row with JQuery

noreply@blogger.com (Steve J Rodgers) — Wed, 18 Feb 2009 21:16:00 +0000

In a project, recently, I wanted to switch over to using the CSS Friendly Control Adapters to get the GridView to render its TR’s and TD’s with a CSS class so that all the styling could be dropped into a style sheet. The reason for doing this was because we wanted to highlight the row underneath the mouse by leveraging JQuery magic, thus improving the end user experience when there are many rows (See image below)

The problem with the CSS Friendly Control Adapters is the all or nothing behaviour. Once you activate them in your project, they have global effect. I went looking for a mechanism that would allow me to turn off the effect on a per GridView basis and was initially excited to see the GridView attribute AdapterEnabled="false"...but after a short test, it became apparent that it doesn’t work!

So, I decided to dump the CSS Friendly Control Adapters and go for a home grown route instead.

The first thing to do is to *remove* <RowStyle> and <AlternatingRowStyle> elements in the GridView and add a CssClass=”selectableGridView” (see image below):

If you fail to remove these elements, they produce HTML as seen below (see how the element gets translated into a style='....' in the HTML)

....and don't forget to add the CssClass=”selectableGridView” to the GridView (as marked in the green square)

The reason for removing them is because we’re going to be using JQuery to add a class dynamically to the row when the mouse is over it and this will have no effect whatsoever if the local styling is left in place. By the way, there's another bonus for doing this and that's to reduce the size of the page which will therefore increase page load time.

So, the JQuery code looks like this:

The JQuery code has two jobs it must do. First, it needs to put back the row style and alternating row style. This is done with the following code:

$('.selectableGridView tr:odd').not(':has(th)').addClass('SelectableGridViewAlternateRow');

$('.selectableGridView tr:even').not(':has(th)').addClass('SelectableGridViewRow');

The first line applies the alternating row style via the class .SelectableGridViewAlternateRow and the second line applies the normal non alternating row style via the class .SelectableGridViewRow. We need to be careful not to include the rows that are in the table header, hence the .not(':has(th)') selector to filter those guys out.

The next piece of JQuery magic is to highlight the row underneath the mouse.

$('.selectableGridView tr').not(':has(th)').mouseover(function() {

$(this).addClass('SelectableGridViewHighlightRow');}).mouseout(function()
$(this).removeClass('SelectableGridViewHighlightRow');});

Again, we simply filter out the rows in the header and then apply the .SelectableGridViewHighlightRow class in mouseover and then remove it in mouseout.

To finish up, the style sheet sets up the rules needed to bring it all together

understanding C#'s yield return statement

noreply@blogger.com (Steve J Rodgers) — Sat, 27 Dec 2008 19:57:00 +0000

The C# yield return statement causes the C# compiler to generate a fair amount of additional IL instructions. This generated code can easily be seen with a tool like Reflector. Although, understanding exactly how the generated code works is not especially easy from first glance since it is rather verbose and somewhat lacking in useful variable names.

A first port of call might be to extract the generated code with Reflector into a Visual Studio .NET C# source file. Sadly, an attempt at compilation will result in errors :( It turns out that the generated IL code does some things that ordinary C# programs are forbidden to do.

Specifically, the iterator syntax magic creates an implementation of IEnumerator.MoveNext() that can be called multiple times, with each call returning to the same point it was at previously, prior to returning last time round. So how does it do that? How can you call a method multiple times and each time have it resume from the exact same point it left previously?

To see this programming style in action, one approach might be to write a simple program from scratch that demonstrates how you could mimic the behaviour of calling a method multiple times and returning to the same point you previously left off. C# is not going to be the right language choice since it forbids the very programming style we want to emulate! It turns out that a simple C++ program is a good candidate for demonstrating the concept and has the benefits of being compilable and therefore debuggable and also reasonably easy to understand.

As an example, consider the following C++ program that displays the first 6 prime numbers with a function GetPrime() that when called each time will return the next prime number in the array.

For simplicity, the program uses several global variables but it’s not hard to imagine these being hoisted into a class as member variables with the GetPrime() function elevated to method status.

The program begins life by calling GetPrime() for the first time. At this time, the global variable called ‘state’ has a value of zero, so the code enters the while loop and extracts the first prime number from the array and sets the global variable ‘state’ to 2 before returning the prime number from the function. The next call into GetPrime(), we note that ‘state’ has a value of 2, so it will trigger the case that causes the code to jump back into the middle of the while loop (effectively jumping back to the exact position where it left last time had it not returned from the function) with goto getAnotherPrime and so the code loops round to extract the next prime number from the array and returns it to the caller. When the global variable ‘count’ is no longer less that the number of primes in the array, the while loop in GetPrime() will drop out and cause the function to return zero, thus causing the while loop in _tmain() to terminate.

The naughty part of the code from a C# perspective is the goto label (getAnotherPrime) appearing after a return statement, something the C# compiler considers to be unreachable code (which seems quite reasonable).

So the secret of the technique is to maintain a state machine in memory of where the code is at in the loop. If ‘state’ is 2, then it means the next call to GetPrime() should re-enter the loop at the place it last left off (that place being just after the return statement). If 'state' is 0, then this is the very first call into the function and iteration is commencing. When 'state' has the value 1, it doesn't stay that way for long since the code will loop back round and soon become 2 again. The assignment of value 1 into 'state' doesn't have much effect other than keeping the compiler happy such that the label actually serves a purpose.

If you understand the above code then it should now be reasonably trivial for the reader to decompile the following C# program with Reflector and see how it uses this exact same state machine technique in IEnumerator.MoveNext():

Cloud Computing

noreply@blogger.com (Steve J Rodgers) — Sat, 01 Nov 2008 14:23:00 +0000

I did not attend PDC this year so I'm blogging on the back of having streamed the Ray Ozzie keynote.

I feel sure I won't be the only person to wonder whether Cloud computing is likely to be a huge success for Microsoft. In theory, it makes a lot of sense, but in practice, I can't help wondering whether this is to a large extent another 'Hailstorm'-esque Microsoft dream. Will companies really be queuing up to have Microsoft data centres host their application code and corporate data? However wonderful the platform may turn out to be, what does it mean to pass responsibility for the safe keeping of your data with a third party like Microsoft?

Why do we need Cloud computing anyway? What does it do such that we cannot live without it? I mean, if we look at .NET and ask the same question, the answer seems obvious - we could not live without it and thank goodness the COM era came to an end. Anyone who uses a computer in the modern world reaps benefit from the technological innovation of .NET - will the same be true of a Microsoft cloud?

Well, I guess the cloud could provide unlimited scalability with that kind of horsepower packed into the huge data centre. But I wonder how many companies will actually need that kind of scalability? And doesn't scalability really boil down to writing code that can be scaled in the first place as opposed to taking any old bit of code and throwing more cores at it? I'm thinking of plentyoffish.com when I say this - one smart guy (Markus Frind), 2 databases, one web server and thousands of hits per day with a truly scalable piece of software. I'm pretty sure he doesn't need the cloud and I'm pretty sure he gets more hits than most companies who will sign up for the cloud.

Failover also has to be a consideration in any scalable application, but do we not already have web server farms and SQL Server clusters that keep the ecosphere of Microsoft applications more than available?

To a large extent, I think it's going to boil down to price. If Microsoft can host your code and data in their cloud at a significantly reduced cost to your business than you hosting it, then perhaps they're onto a winner. But even if they do manage to make the cloud financially competitive, the question still remains as to whether you trust Microsoft to be the caretakers of your company's greatest assets.

JSONized query strings

noreply@blogger.com (Steve J Rodgers) — Fri, 30 May 2008 08:50:00 +0000

I often have to Response.Redirect to an ASP.NET page that takes a lot of parameters. There are a few ways of doing this. One way might be to invoke the page with a query string that contains the parameters:

Foo.aspx?a=66&b=77

If you think of the query string parameters as bunch of properties on a class then you could easily see how one might author that class to also serialize and deserialize the query string by leveraging StringBuilder.Append or String.Format and String.Split etc etc.

I’ve been working with Microsoft AJAX recently and I'd used the text based JSON serializer a couple of times and it got me thinking about how I might leverage that to serialize my object properties to and from the query string. [The XmlSerializer might seem like another approach, but ASP.NET really doesn’t like angle brackets (even encoded) sent as data in the query string – it barfs in case you were wondering with a ‘that data looks very suspicious’ type message.]

So I decided to give the JSON parser a whirl and it works like a charm. Here’s what my JSON encoded query string looks like:

Foo.aspx?qps={"A":66,"B":77}

Here's the class:

Here's the caller:

Here's the callee:

I *always* wrap the FromJSON call in a try / catch block in case someone tries to send a hacked query string that clearly won’t deserialize.

Creating 'Expression Blend' ScrollBars in WPF

noreply@blogger.com (Steve J Rodgers) — Sun, 04 May 2008 21:48:00 +0000

The scroll bars in Expression Blend are very nice. Nice enough that I thought I’d spend some time this afternoon figuring out how I could modify the WPF scroll bar control template. Fortunately, it turned out that there really wasn’t that much work involved. Here’s the result:

I started off by grabbing the template from

MSDN. The scroll bar template consists of a style that brings into play either the VerticalScrollBar template or the HorizontalScrollBar template via the Orientation dependency property as seen:

The remaining discussion will only focus on the VerticalScrollBar, since the solution is almost exactly the same for HorizontalScrollBar.

The RepeatButton defined in the VerticalScrollBar template seen at Grid="0" and again at Grid="2" defines the up arrow and down arrow respectively. I made these a little more elongated to mirror the Blend arrows by changing the content properties as follows:

Top arrow: Content="M 0 8 L 8 8 L 4 0 Z"

Bottom arrow: Content="M 0 0 L 4 8 L 8 0 Z"

The scroll thumb also needed some attention. The shape of the thumb at both ends is more rounded than the default, so I increased the CornerRadius:
CornerRadius="4"

Also, the thumb in blend has no border, so I removed the BorderBrush and set the:

BorderThickness="0"

Another difference is that the thumb is highlighted when the mouse is over it and changes colour to black while it is being dragged. Both of these are dependency properties that can be modified to the appropriate values with triggers:

Notice that I had to give the Border a name ‘roundedBorder’ so that the triggers could reference it.

ScrollBarLineButton defines the style and template for the repeater button that houses the arrows (which will end up being up or down for vertical scroll bar. And left or right for a horizontal scroll bar). The template for ScrollBarLineButton acquires the visual for the arrow by databinding to the Content property of the template parent – a neat trick that means only one ScrollBarLineButton needs to be defined for the whole template to be able to deal with all four arrows.

To get the ScrollBarLineButton to look like the blend version, I had to make a few more changes. The arrow is highlighted when the mouse is over it – in much the same way as the thumb. To achieve this, I gave the Path a name ‘glyph’ and then changed the trigger ‘IsMouseOver’ to retarget to ‘glyph’ Fill to the colour: GlyphMouseOver. The IsPressed trigger also needs to mirror the thumb and sets the ‘glyph’ Fill to black.

Finally, I also had to change some of the brushes defined for the scrollbar. Here are the changed versions:

WPF CoverFlow Clone

noreply@blogger.com (Steve J Rodgers) — Wed, 30 Jan 2008 18:12:00 +0000

I recently decided to spend some time hacking up a CoverFlow clone in WPF. Of course, what I managed to achieve in the space of a day is nowhere near as good as the real CoverFlow application that Apple deploys but that's not the point! The point is, it amazes me how quickly and effortlessly I was able to do it with the power of WPF. It also amazes me how long something similar would have taken in any previous technology like Windows Forms or Win32!

Here's what the 'final' XBAP version looks like:

My approach was to almost completely restyle a ListBox. The first step was to redefine the ControlTemplate of ListBoxItem to be a Grid of 1 row and 1 column containing a StackPanel which in turn contained both the ContentPresenter and a Rectangle. The rectangle is there to produce the reflected image of the ContentPresenter.

Here's the XAML for doing that:

The VisualBrush used to paint the Rectangle has to be flipped in the Y-axis with a ScaleTransform and then put back into the correct position with the TranslateTransform. The TranslateTransform figures out how much to offset in the Y axis via databinding to the ActualHeight of the ContentPresenter. The OpacityMask applied to the Rectangle ensures that the reflection gradually dissolves away.

The StackPanel that contains the ContentPresenter and Rectangle (reflected image) looks like this:

This has a couple of transforms that do nothing until they are animated later; a TranslateTransform and a ScaleTransform.

When the ListBoxItem is selected, several animations run in parallel, effectively moving the StackPanel down in the Y axis by running the TranslateTransform while at the same time running a ScaleTransform which enlarges it in X and Y. The combined effect of these animations running in parallel is the sensation that the selected ListBoxItem springs forward towards the end user.

The animations are initiated by EventTrigger's; one each for the routed events: ListBoxItem.Selected and ListBoxItem.Unselected. Here's the XAML for the animations in their respective EventTrigger's

When the ListBoxItem becomes Unselected, the Unselected EventTrigger ensures the StackPanel moves back into it's original position and size prior to being selected - effectively reversing the work done of the Selected EventTrigger.

Avoid CrpytoStream.Flush()

noreply@blogger.com (Steve J Rodgers) — Thu, 21 Jun 2007 03:48:00 +0000

I needed to attend to some code that was violating an FxCop rule earlier. The code snippet looks something like this:

using (CryptoStream cryptoStream = new CryptoStream(outputStream...))
{
cryptoStream.Write(data, 0, data.Length);
cryptoStream.Close();
encrypted = outputStream.ToArray();
}

The FxCop rule being violated is that we are calling Close and yet Dispose will automatically be called because we are in the context of a using construct.

So I figured I'd just call Flush() instead of Close() - so it would look like this:

using (CryptoStream cryptoStream = new CryptoStream(outputStream...))
{
cryptoStream.Write(data, 0, data.Length);
cryptoStream.Flush();
encrypted = outputStream.ToArray();
}

That turned out to be bad karma and barfed during unit testing with:
System.Security.Cryptography.CryptographicException : Padding is invalid and cannot be removed

I had a look at CrytoStream.Flush() with Reflector and it looks like this:

public override void Flush()
{
}

Hmmmm not much going on there seeing as the documentation says -
"Clears all buffers for this stream and causes any buffered data to be written to the underlying device"

So I checked out the CryptoStream.Dispose() and that makes a call to CryptoStream.FlushFinalBlock() prior to calling CryptoStream.Close(). So I have replaced our call to Flush() with FlushFinalBlock()...makes me wonder whether Flush() was an intentional override that does absolutely nothing whatsoever other than inhibit base class behavior....?

Vista graphics card driver joys...

noreply@blogger.com (Steve J Rodgers) — Sat, 02 Jun 2007 11:15:00 +0000

My primary machine is a DELL D820 and I'm running Vista RTM. I was thinking that not only the graphics seemed a bit sluggish but also Vista Performance tool (just go Start->Performance Information & Tools) reported my Graphics rating as 2.3 out of 5.9 which aint so good. I checked out the installed driver and saw that it was a Microsoft generic driver so I surfed to the DELL website and had a quick look to see if there was a better driver. Sure enough, I found the Nvidia driver and installed it. After rebooting, I asked Performance Information & Tools to update my score and it then came in at 3.6 and the UI is really, really zippy compared to what it was.

So if you're running Vista and you're using the generic display driver, go find the non generic one and enjoy Vista even more :)

Debugging hints & tips

noreply@blogger.com (Steve J Rodgers) — Thu, 31 May 2007 07:25:00 +0000

I've been doing a lot of spelunking with WinDBG recently. There's a lot to know and the documentation can fall short sometimes. Tess's blog usually has enough entries that you can usually figure things out by looking at her examples and scenarios. I always find myself referring back to her blog and a bunch of other blogs which I referred to in a previous blog entry.

Primarily, I'm posting this entry as a future helper for myself. Invariably, I draw the information I need from more than one source so I am effectively collating as much of that that useful information here in one place. If that helps anyone else out along the way, then more power to the blog!

Need to get yourself set up for a WinDBG debug session? Here's what you need to do:

1) Create a directory C:\MyLocalSymbols

2) Install symbols for your operating system to C:\MyLocalSymbols - get symbols from: here

3) Install Windows Debugging Tools - get it from: here

4) Set up _NT_SYMBOL_PATH (choose properties on My Computer->Advanced->Environment Variables->New) to SRV*C:\MyLocalSymbols*http://msdl.microsoft.com/download/symbols
This will save you from having to set the path up in WinDBG and will do it globally for the operating system

How do I load the CLR debug extension SOS.DLL into WinDBG?

1) Type the following command:
.loadby sos mscorwks

What is the WinDBG command to get a list of CLR instances of a given type, e.g. System.AppDomain?

1) !dumpheap -type System.AppDomain

e.g.
0:009> !dumpheap -type System.AppDomain
Address MT Size
012611b4 790fb998 100
01261218 790fbdcc 40
012688c8 790fb998 100
0126bd28 790fbdcc 40

What is the WinDBG command to see the fields of an object?

1) Find the object you are interested and use !do addressgoeshere - (use the previous item as a starting point if you don't currently have an object address!)

In this example we are dumping an AppDomain instance found in the previous example - notice we are using the address column not the MT column!
0:009> !do 012611b4
Name: System.AppDomain
MethodTable: 790fb998
EEClass: 790c3608
Size: 100(0x64) bytes
(C:\WINDOWS\assembly\GAC_32\mscorlib\2.0.0.0__b77a5c561934e089\mscorlib.dll)
Fields:
MT Field Offset Type VT Attr Value Name
790f9ce8 4000184 4 System.Object 0 instance 01284ed8 __identity
7910f540 4000185 8 ....AppDomainManager 0 instance 00000000 _domainManager
790feb44 4000186 c ...ections.Hashtable 0 instance 00000000 _LocalStore
790fbdcc 4000187 10 ...em.AppDomainSetup 0 instance 01261218 _FusionStore
791094f0 4000188 14 ...y.Policy.Evidence 0 instance 00000000 _SecurityIdentity
79124318 4000189 18 System.Object[] 0 instance 00000000 _Policies
7911d470 400018a 1c ...yLoadEventHandler 0 instance 00000000 AssemblyLoad
79116ffc 400018b 20 ...solveEventHandler 0 instance 00000000 TypeResolve
79116ffc 400018c 24 ...solveEventHandler 0 instance 00000000 ResourceResolve
79116ffc 400018d 28 ...solveEventHandler 0 instance 00000000 AssemblyResolve
79116ffc 400018e 2c ...solveEventHandler 0 instance 00000000 ReflectionOnlyAssemblyResolve
791034f8 400018f 30 ....Contexts.Context 0 instance 012687c4 _DefaultContext
7911db24 4000190 34 ...ActivationContext 0 instance 00000000 _activationContext
7911dc44 4000191 38 ...plicationIdentity 0 instance 00000000 _applicationIdentity
7911dd20 4000192 3c ....ApplicationTrust 0 instance 00000000 _applicationTrust
79118234 4000193 40 ...ncipal.IPrincipal 0 instance 00000000 _DefaultPrincipal
79103b10 4000194 44 ...cificRemotingData 0 instance 01268688 _RemotingData
7910d6f8 4000195 48 System.EventHandler 0 instance 00000000 _processExit
7910d6f8 4000196 4c System.EventHandler 0 instance 00000000 _domainUnload
7911d508 4000197 50 ...ptionEventHandler 0 instance 0129d118 _unhandledException
790fe234 4000198 54 System.IntPtr 0 instance 1345952 _dummyField
7911d974 4000199 58 System.Int32 0 instance 0 _PrincipalPolicy
79105040 400019a 5c System.Boolean 0 instance 0 _HasSetPolicy

Need to drill down into a field of an object you just dumped?

1) We want to dump the field called _FusionStore of the AppDomain object we just dumped

2) Use the 'Value' column from the previous !do command for the field called _FusionStore
e.g.
0:009> !do 01261218
Name: System.AppDomainSetup
MethodTable: 790fbdcc
EEClass: 790fbcfc
Size: 40(0x28) bytes
(C:\WINDOWS\assembly\GAC_32\mscorlib\2.0.0.0__b77a5c561934e089\mscorlib.dll)
Fields:
MT Field Offset Type VT Attr Value Name
79124318 40001a3 4 System.Object[] 0 instance 01261240 _Entries
79100ed0 40001a4 20 System.Int32 0 instance 0 _LoaderOptimization
790fa4b0 40001a5 8 System.String 0 instance 00000000 _AppBase
7915cb08 40001a6 c ...DomainInitializer 0 instance 00000000 _AppDomainInitializer
79124318 40001a7 10 System.Object[] 0 instance 00000000 _AppDomainInitializerArguments
7915ce5c 40001a8 14 ...tivationArguments 0 instance 00000000 _ActivationArguments
790fa4b0 40001a9 18 System.String 0 instance 00000000 _ApplicationTrust
79124508 40001aa 1c System.Byte[] 0 instance 00000000 _ConfigurationBytes

How do I dump an array?

1) Notice the array in the previous item called _Entries? Use !da addressofobject

In this example we want to dump the field '_Entries':

e.g.
0:009> !da 01261240
Name: System.String[]
MethodTable: 79124318
EEClass: 7912488c
Size: 80(0x50) bytes
Array: Rank 1, Number of elements 16, Type CLASS
Element Methodtable: 790fa4b0
[0] 01261530
[1] 01261290
[2] null
[3] null
[4] 012612e4
[5] null
[6] null
[7] null
[8] null
[9] null
[10] null
[11] null
[12] null
[13] null
[14] null
[15] null

What is the WinDBG command to find the current managed exception?

1) !pe

What is the WinDBG command to find the current unmanaged exception?

1) .exr -1

Application seems to generate a lot of exceptions but only one is of concern to you?
You need to product a dump of the program that you can then debug with WinDBG. You'll need to launch the application and then attach the debugger. In a program I was debugging earlier, I was interested in System.NullReferenceException.

1) Create a directory on your hard disk called C:\Dumps

2) Create the following file called trackclr.cfg in the same directory as windbg.EXE (on my machine that was "C:\Program Files\Debugging Tools For Windows"):
<ADPlus>
<Settings>
<RunMode>CRASH</RunMode>
<Option>Quiet</Option>
</Settings>
<Exceptions>
<Option>NoDumpOnFirstChance</Option>
<Config>
<Code>clr</Code>
<Actions1>Void</Actions1>
<CustomActions1>
.loadby sos mscorwks;
!stoponexception System.NullReferenceException 4;
.if(@$t4==1)
{
.dump /ma /u c:\\Dumps\\NullRef.dmp
}
</CustomActions1>
<ReturnAction1>gn</ReturnAction1>
</Config>
</Exceptions>
</ADPlus>

3) Run the target program (the one you want to debug)

4) Attach the debugger via the following command line:
adplus -c trackclr.cfg

5) Crash dump will appear in C:\Dumps

6) Get some very useful information from the dump via the following command: !analyze -v

7) From the previous command (!analyze -v), grab the IP address e.g. FAULTING_IP: +957984d and then do a !U addressgoeshere e.g. !U 957984d
This will show you which method and the JIT'd instructions - keep an eye out for the IP itself which is highlighted by WinDBG with chevrons: >>> e.g.
>>> 0957984d 8b01 mov eax,dword ptr [ecx]

If you're getting a NullReferenceException and it's on an assembly instruction as seen in the example, then examine the machine registers with the command: r
e.g.
0:009> r
eax=01e05ac4 ebx=00000000 ecx=00000000 edx=00000096 esi=01e05ad0 edi=01dfd144
eip=0957984d esp=07dbd718 ebp=00000096 iopl=0 nv up ei ng nz ac pe cy
cs=001b ss=0023 ds=0023 es=0023 fs=003b gs=0000 efl=00010297
0957984d 8b01 mov eax,dword ptr [ecx] ds:0023:00000000=????????

In this example, ecx contains all zeros and yet the machine instruction mov eax,dword ptr [ecx] is trying to dereference the zeros in ecx and assign that to eax - hence an AccessViolation which the CLR will translate to a NullReferenceException

You think there is an object of a certain type that is being accessed by more than one thread but can't be sure?

1) Produce a crash dump or debug live in WinDBG

2) Get a list of objects of that type [see above on how to do that]

3) Pick on one of the objects and see which threads have a reference to it with !gcroot

This example finds all the threads that have a reference to the AppDomain instance whose address we dumped earlier:

e.g.
0:009> !gcroot 012611b4
Note: Roots found on stacks may be false positives. Run "!help gcroot" for
more info.
Scan Thread 0 OSTHread 10a8
ESP:12f010:Root:012687c4(System.Runtime.Remoting.Contexts.Context)->
012611b4(System.AppDomain)
ESP:12f318:Root:0129cf3c(NUnit.ConsoleRunner.ConsoleUi+EventCollector)->
0129d6b0(System.Runtime.Remoting.ServerIdentity)->
012687c4(System.Runtime.Remoting.Contexts.Context)
ESP:12f328:Root:01267e48(NUnit.Util.TestDomain)->
0129cf3c(NUnit.ConsoleRunner.ConsoleUi+EventCollector)->
0129d6b0(System.Runtime.Remoting.ServerIdentity)
ESP:12f32c:Root:0129cf3c(NUnit.ConsoleRunner.ConsoleUi+EventCollector)->
012611b4(System.AppDomain)
ESP:12f364:Root:0129d138(NUnit.Util.TestExceptionHandler)->
0129d118(System.UnhandledExceptionEventHandler)->
01267e48(NUnit.Util.TestDomain)->
0129cf3c(NUnit.ConsoleRunner.ConsoleUi+EventCollector)
ESP:12f36c:Root:0129cf3c(NUnit.ConsoleRunner.ConsoleUi+EventCollector)->
012611b4(System.AppDomain)
ESP:12f370:Root:01267e48(NUnit.Util.TestDomain)->
012611b4(System.AppDomain)
ESP:12f38c:Root:01267e48(NUnit.Util.TestDomain)->
012611b4(System.AppDomain)
ESP:12f394:Root:0129cf3c(NUnit.ConsoleRunner.ConsoleUi+EventCollector)->
012611b4(System.AppDomain)
ESP:12f3d8:Root:0129cf3c(NUnit.ConsoleRunner.ConsoleUi+EventCollector)->
012611b4(System.AppDomain)
ESP:12f3e0:Root:01267e48(NUnit.Util.TestDomain)->
012611b4(System.AppDomain)
ESP:12f3e4:Root:01267e48(NUnit.Util.TestDomain)->
012611b4(System.AppDomain)
Scan Thread 2 OSTHread a74
Scan Thread 4 OSTHread 938
Scan Thread 5 OSTHread 10d0
Scan Thread 8 OSTHread 258
Scan Thread 9 OSTHread ca8
Scan Thread 11 OSTHread 7f4
Scan Thread 14 OSTHread 16a8
Scan Thread 18 OSTHread 31c
Scan Thread 19 OSTHread b84
Scan Thread 20 OSTHread a18
Scan Thread 21 OSTHread 86c
Scan Thread 22 OSTHread 10c0
Scan Thread 23 OSTHread 11c4
Scan Thread 24 OSTHread 1348
Scan Thread 25 OSTHread 3e4
Scan Thread 26 OSTHread de8
DOMAIN(001489A0):HANDLE(WeakLn):8e10fc:Root:012687c4(System.Runtime.Remoting.Contexts.Context)->
012611b4(System.AppDomain)
DOMAIN(001489A0):HANDLE(Strong):8e1140:Root:012f59e8(System.Threading.Thread)->
012687c4(System.Runtime.Remoting.Contexts.Context)
DOMAIN(001489A0):HANDLE(Strong):8e1150:Root:0129d6b0(System.Runtime.Remoting.ServerIdentity)->
012687c4(System.Runtime.Remoting.Contexts.Context)
DOMAIN(001489A0):HANDLE(Strong):8e1154:Root:01284ed8(System.Runtime.Remoting.ServerIdentity)->
012611b4(System.AppDomain)
DOMAIN(001489A0):HANDLE(Strong):8e11fc:Root:012611b4(System.AppDomain)->
012611b4(System.AppDomain)
DOMAIN(001489A0):HANDLE(WeakSh):8e12d0:Root:012f59e8(System.Threading.Thread)->
012611b4(System.AppDomain)
DOMAIN(001489A0):HANDLE(Pinned):8e13fc:Root:02261010(System.Object[])->
012687c4(System.Runtime.Remoting.Contexts.Context)

Want to find out which threads are running in your application?

1) !threads

e.g.
0:009> !threads
ThreadCount: 17
UnstartedThread: 0
BackgroundThread: 15
PendingThread: 0
DeadThread: 0
Hosted Runtime: no
PreEmptive GC Alloc Lock
ID OSID ThreadOBJ State GC Context Domain Count APT Exception
0 1 10a8 00150b50 2006020 Enabled 00000000:00000000 00198f90 0 STA
2 2 a74 0015d290 b220 Enabled 00000000:00000000 001489a0 0 MTA (Finalizer)
4 3 938 0018d488 1220 Enabled 00000000:00000000 001489a0 0 Ukn
5 4 10d0 001ab710 80a220 Enabled 00000000:00000000 001489a0 0 MTA (Threadpool Completion Port)
8 5 258 06fa3c90 200b020 Enabled 00000000:00000000 00198f90 0 MTA
9 6 ca8 06fa48f8 7220 Disabled 00000000:00000000 00198f90 0 STA
11 7 7f4 06fdce90 b220 Enabled 00000000:00000000 00198f90 0 MTA
14 8 16a8 001bbcc0 180b220 Enabled 00000000:00000000 001489a0 0 MTA (Threadpool Worker)
18 9 31c 07029e80 200b220 Enabled 00000000:00000000 00198f90 0 MTA
19 a b84 0a885508 200b220 Enabled 00000000:00000000 00198f90 0 MTA
20 b a18 0a8b0208 200b220 Enabled 00000000:00000000 00198f90 0 MTA
21 c 86c 0a8b4160 200b220 Enabled 00000000:00000000 00198f90 0 MTA
22 d 10c0 0a8b49e8 200b220 Enabled 00000000:00000000 00198f90 0 MTA
23 e 11c4 0a8b5080 200b220 Enabled 00000000:00000000 00198f90 0 MTA
24 f 1348 0a8b6b40 200b220 Enabled 00000000:00000000 00198f90 0 MTA
25 10 3e4 0a8ba158 200b220 Enabled 00000000:00000000 00198f90 0 MTA
26 11 de8 0a8d0a58 200b220 Enabled 00000000:00000000 00198f90 0 MTA

Want to see the managed stack of a particular thread?

First you need to context switch to the thread of interest in WinDBG, then dump its stack

1) Context switch to a thread with this command: ~threadnumber s
e.g. from previous !threads call, pick a thread ID from the far left column from the !threads command output
~20 s

2) Dump the managed call stack for the thread currently switched in:
!clrstack

Want to see parameters and autos as part of the stack dump?

1) Use !clrstack -a

Application is hung and you want to get a crash dump?

1) adplus -hang -pn foo.exe

Web 2.0 and other musings

noreply@blogger.com (Steve J Rodgers) — Wed, 11 Apr 2007 14:13:00 +0000

I can't recall where I was or how I heard of the term Web 2.0 - It wasn't that long ago...within the last 6 months for sure. When I first heard it, I wondered what it could be and headed to the usual haunt for an explanation. It all felt a bit wooley to be honest. I then saw an important reference to the source of the term....that certainly didn't help...The first port of call in my opinion is much better....

I was having a chat on Messenger with my good friend (and previous business partner) Kevin Jones this evening about what Web 2.0 actually is. We both agreed immediately that it is a Web App that behaves as if it were a thick client app...an Ajax app for sure. None of this long page load malarky...highly responsive...just like every google app...just like a thick client app.

What else? I think that Google dumping web services as the programmable interface to their business is a sign. I'm starting to wonder whether web services are going to be important in the long term with Ajax and JSON lurking in the background. I think web services are a master stroke for linking together systems that otherwise couldn't talk to one another - but supposing everything starts to converge on Web 2.0? The industry will never give up on the web as the most important platform - it will only get better...The web already is the one platform.

I also started thinking about ASP.NET AJAX. I have not programmed it yet but it's an add on to ASP.NET. In other words, Web 2.0 as a metaphor for Web apps was not in the minds of the ASP.NET architects at Redmond when they set about designing the replacement technology for ASP. This started me thinking about Ruby On Rails...this is more recent than ASP.NET so maybe this has an architecture designed with Web 2.0 as it's central metaphor? I have no idea yet as I haven't had a chance to look at it, but I will be doing so shortly!

Everything is heading towards being free to the end user on the web. I'm fairly certain I read that in a Paul Graham essay but don't ask me which one!! This feels right to me. I never pay for something on the web if I can find a way to get it for free with a little bit of extra googling. This is important. I think it's a sign and I certainly hadn't been thinking about it until I read that.

That train of thought started me thinking about open source software - PHP, MySQL, Ruby on Rails, Mono..etc...no matter how hard Redmond tries to run away with technology, these guys follow with free software / software tools...I was reading today that Adsense is built with MySQL as it's backend DB.

There are so many sites out there on Apache (free), running PHP (free) connecting to MySQL (free) that it's hard to ignore it. The end user's apparent running costs must be lower - I'm assuming that the software dev team are good and know their stuff. Why wouldn't you use it? Clearly, it scales!

I don't really have any conclusions to draw from these musings but I am getting a very strong sense of which way the wind is blowing.

Being compared to when you didn't expect it

noreply@blogger.com (Steve J Rodgers) — Wed, 28 Mar 2007 06:35:00 +0000

I've been doing a lot of migration work on a .NET v1.1 code base to .NET 2.0 recently. I just ran into a (gnarly) documented change in the implementation of ArrayList.Contains(object item) that was causing a unit test to fail....here's the relevant extract from the remarks section towards the end of the document [1] (http://msdn2.microsoft.com/en-us/library/system.collections.arraylist.contains.aspx)

In our case we were passing in items that had overidden Object.Equals. Since this method is now invoked by ArrayList.Contains() in .NET v2.0 but was not previously in .NET v1.1, our implementation of Object.Equals was incorrect for this scenario.

[1]
"Starting with the .NET Framework 2.0, this method uses the collection’s objects’ Equals and CompareTo methods on item to determine whether item exists. In the earlier versions of the .NET Framework, this determination was made by using the Equals and CompareTo methods of the item parameter on the objects in the collection"

The Wingsuit

noreply@blogger.com (Steve J Rodgers) — Tue, 20 Feb 2007 08:40:00 +0000

The race is on to develop a wingsuit that allows the wearer to do away with a parachute entirely...according to this article, the wingsuit increases the horizontal component from normal freefall rate of 0.5m to wingsuit wearer 3.0m per 1.0m decent

Truly Amazing I

Truly Amazing II

Debugging Internet Explorer hosted Windows Forms Controls

noreply@blogger.com (Steve J Rodgers) — Thu, 04 Jan 2007 02:00:00 +0000

Our product for historical reasons has some .NET v1.1 Windows Forms user controls embedded in ASP.NET pages.

Running these pages on a machine that has .NET v2.0 installed causes things to not work. Basically the unmanaged host iexplore.exe has to pick a version of the CLR to load when it is about to load the controls and it will pick the latest and greatest v2.0 in our case. This of course, is not what we want. It is possible to constrain the options by having an iexplore.exe.config that specifies the versions it is allowed to choose from. In our case, the config file looks like this:

<configuration>
<startup>
<supportedRuntime version="v1.1.4322"/>
</startup>
</configuration>

A useful tip in debugging Windows Forms controls embedded in this way is to activate IEHost logging

Compilation Error: ‘The key container name ‘Blah’ does not exist’

noreply@blogger.com (Steve J Rodgers) — Wed, 22 Nov 2006 01:17:00 +0000

I just spent a couple of hours solving this one – when your AssemblyInfo.cs file references a key container (e.g. [assembly: AssemblyKeyName("Blah")]) that doesn’t exist or it doesn’t have sufficient access permissions you’ll get this error.

Fixing this problem used to involve going to the registry entry: HKLM\Software\Microsoft\Cryptography\MachineKeys and setting the permissions to give yourself access to all the keys in the key store – (well you are logged in as Admin after all ;)

The key store has moved from the registry to the file system with Windows 2000 apparently – It’d been a while since I’d been in there as you can tell. You want to go to:
C:\Documents and Settings\All Users\Application Data\Microsoft\Crypto\RSA\MachineKeys

...and change the DACL to give yourself permissions.

In my case, the key container was effectively an orphan – the account that created it must have been deleted and so I had to take ownership of the orphaned file (as admin) and set the DACL up to give myself permissions

As a test for the future I decided to try to access that directory from my Vista box. As I surfed to my Vista ‘C:\Documents and Settings’ folder I was prompted for elevation – I accepted the elevation but the DACL killed the elevation according to the UI – So I checked out the security for the folder and I was marked as having ‘Full Control’ – geez – I hope I don’t ever see this compilation error when I move over to Vista

the death of fastfood as we know it

noreply@blogger.com (Steve J Rodgers) — Fri, 17 Nov 2006 13:14:00 +0000

I have been thinking for a long while now that fast food will one day become what smoking has now become - a thing that is discouraged and not allowed in public places. When I read this article on the BBC news website, I had to smile.

Chris Brumme blogs again...

noreply@blogger.com (Steve J Rodgers) — Mon, 25 Sep 2006 06:34:00 +0000

Chris Brumme has posted to his blog after a 2 year hiatus...I wonder if he'll start blogging on a more frequent basis from now on?...one can only hope so.

Sticky silicon

noreply@blogger.com (Steve J Rodgers) — Mon, 18 Sep 2006 22:49:00 +0000

From the BBC News website:Sticky silicon

SQL Server 2005 PIVOT woes

noreply@blogger.com (Steve J Rodgers) — Tue, 15 Aug 2006 01:49:00 +0000

I spent a morning playing with the new SQL Server 2005 PIVOT command in T-SQL.

I created a new database that has 2 columns: ID(int), Field(nvarchar(50), DataValue(nvarchar(50))

I put some data in:
insert into SomeData values('Shift', 'Day Shift')
insert into SomeData values('Shift', 'Night Shift')
insert into SomeData values('Shift', 'Day Shift')
insert into SomeData values('Shift', 'Morning Shift')

and then issued my PIVOT command:
SELECT ID, [Day Shift] AS DayShift, [Morning Shift] AS MorningShift, [Night Shift] AS NightShift FROM SOMEDATA
PIVOT
(
MIN([Field])
FOR DataValue IN ([Day Shift], [Morning Shift], [Night Shift])
) p

Things to watch out for...you must alias the PIVOT with a variable even if you don't use it anywhere - in my case I chose the letter p

The items in the FOR list cannot be calculated from a subquery so you must list them :(

If you import a SQL Server 2000 database that has the same schema as my example and then try to issue the above command, you'll get back a cryptic error like this:
Msg 102, Level 15, State 1, Line 5
Incorrect syntax near '('.

You need to change the compatibility level of the database to SQL Server 2005 otherwise the functionality is restricted to SQL Server 2000 - PIVOT command is not available for SQL Server 2000. It took me a long time to figure this out because that error message is not much use! You change the compatibility level to SQL Server 2005 with sp_dbcmptlevel e.g.
EXEC sp_dbcmptlevel 'RevesbyProjectData', '90';

where the first parameter is the name of the database and the second parameter is the version of SQL Server: 80 is 2000 and 90 is 2005

Internet memory lane

noreply@blogger.com (Steve J Rodgers) — Sat, 05 Aug 2006 07:29:00 +0000

Interesting trip down internet memory lane - Seems hard to believe in August 1995 there were only 18,957 web sites in the world.

ALT-TAB Vista

noreply@blogger.com (Steve J Rodgers) — Mon, 17 Jul 2006 00:41:00 +0000

I just found out that ALT-TAB now includes the mouse in Vista...just do a single ALT-TAB, keep the ALT key pushed down and then move the mouse into the ALT-TAB area and hover over whichever item you're interested in and it automatically selects that item

Getting to Low Earth Orbit

noreply@blogger.com (Steve J Rodgers) — Sun, 09 Jul 2006 03:47:00 +0000

If you have plans to achieve Low Earth Orbit then this is essential reading!

Debugging release apps

noreply@blogger.com (Steve J Rodgers) — Thu, 29 Jun 2006 01:57:00 +0000

Debugging is actually quite hard in a release environment. I have learned a great deal about how to do this by reading the following blogs:

Mike Taulty has three good blogs:
Part 1, Part 2 and Part 3

Tess Ferrandez has the ultimate blog for debugging managed apps

John Robbins rates Tess above himself

TLA decoder

noreply@blogger.com (Steve J Rodgers) — Tue, 27 Jun 2006 23:01:00 +0000

Occasionally I come across a TLA and have no idea what it means - by chance I found a web site which has some pretty good suggestions:

http://www.acronymfinder.com/

500 GHz anyone??

noreply@blogger.com (Steve J Rodgers) — Wed, 21 Jun 2006 00:56:00 +0000

If you have access to some sophisticated cooling equipment (I was tempted to say cool equipment but thought better of it) and some non silicon material then it's possible to increase the processing speed to 500 GHz