Scott Seely

Review of RedGate .NET Reflector Pro

2010-03-17T00:38:00Z

Disclaimer: RedGate is a sponsor of devlicio.us and offered a copy of the product and a ThinkGeek gift certificate as an incentive to review their product. This review is the work of the author and was not approved by anyone other than the author. There, now you know the kind of taint this review has. Please keep reading anyhow. OK? Good!

.NET Reflector is part of any respectable .NET developer’s tool belt. When you want to figure out how something works, why your code breaks when interacting with some library, you view the assembly through .NET Reflector’s lens. The latest version, 6.1.0.11, will display the IL in an assembly as IL, Managed C++, VB.NET, C#, Delphi, or Oxygene. The latest version has been updated to support .NET 4 and allows you to jump into .NET Reflector from Visual Studio. I was disappointed to see that the “Open in .NET Reflector” menu option is only available from the Object Explorer. I would have expected to see this option by right-clicking on the assembly from the References list in the Solution Explorer, but no. Given that other tools (TestDriven.NET in particular) do add this functionality (they actually add “Open in .NET Reflector” from the Solution Explorer!) RedGate needs to address this usability issue.

Otherwise, the free version of .NET Reflector hasn’t changed. It is still a great tool.

So, what about this new, Pro version? First, it costs $195 US. What do you get for that price? You get the ability to generate source code and PDBs so that you can step through the assemblies you use in the languages you know. If you are debugging Microsoft provided assemblies, you can already step through assemblies using the actual source (typically C#) through the Enable .NET Framework Source Stepping option from the Options dialog (in VS 2008/2010, access this dialog from Tools—>Options menu.)

In the past, Microsoft wasn’t always good about keeping their symbol servers and source code servers up to date. Not every group put their code into the repository right away, so service packs and other patches might cause you to lose the ability to step through code. If you use components from other vendors, this option does you no good at all. RedGate is betting that a number of you want to be able to step through all .NET assemblies in VB.NET or C#. At a high level, RedGate generates the source code for an entire assembly and dumps it onto disk. It also writes out a PDB that tells Visual Studio how to map the assembly code to the generated code.

To long time users of .NET Reflector, the code generation piece may sound like old hat. It is. Back in May of 2004, Denis Bauer released a .NET Reflector plug-in that dumps the assembly information as code files (the plug-in was last updated for .NET Reflector v5). If you want a full project file for the dumped files, you used Jason Bock’s FileGenerator plugin. Unfortunately, neither of these allow you to step through code, and that’s what many of us need. .NET Reflector Pro adds that functionality.

The overall experience is seamless. Upon running .NET Reflector, the .NET Reflector top level menu is added to Visual Studio 2008/2010. From here, you can either decompile an assembly in your project, Explore Decompiled Assemblies, or Debug an Executable.

Explore Decompiled Assemblies just pops open the Object Explorer in Visual Studio. I would have expected the list to be reduced to the list of assemblies I had already decompiled, but that isn’t what happened. Debug an Executable is a bit confusing too—it just fires up the executable and attached the debugger. If you have decompiled the assemblies of interest already, you can step through that code. Otherwise, this feature seems to be a bit of a waste. When PDB information does not exist, I would have expected the UI to say something like “.NET Reflector has not created debugging information for the selected executable. Would you like to generate source code and PDBs now?” I should then be able to select the assemblies I want to debug using this new functionality.

All that said, the tool does redeem itself. When selecting .NET Reflector—>Choose Assemblies to Debug, the tool gets things right. This is the only feature in the Pro version that seems to have been completely thought out. At this stage, you are presented with the following dialog:

You can generate the source in C# v2.0/3.0 or Visual Basic 8.0/9.0. You then select the assemblies you would like to be able to step through and press OK. A little while later (time completely dependent on the size of the assembly), you are ready to do source level debugging. In the I tested out, this worked as advertised. I was able to step into System.dll, System.Web.dll, and other assemblies I regularly use. So, for .NET 4.0, clearly a win. F11 works fine, you can set breakpoints etc. For .NET 4.0 developers, this will be very helpful debugging those nasty issues where you need to figure out why your code is causing .NET and other libraries to die.

So, how about Silverlight? I had .NET Reflector generate the source/debug information for System.Windows. Then, I set a breakpoint in the constructor for my Silverlight MainPage.xaml.cs. I was able to step out to MS.Internal.CoreInvokeHandler.InvokeEventHandler.

I tried doing the same thing with the just released Windows Phone SDK. In this case, I was unable to get the application to rebuild correctly and work. After instructing .NET Reflector to generate the information for System.Windows for a Windows Phone Application, I saw this dialog:

After generating the assemblies, Reflector pointed the references in the solution to the new assemblies. Upon debugging, I saw this message (followed by several more for the other updated assemblies):

---------------------------
.NET Reflector
---------------------------
The loaded assembly "System.Windows" is not the one .NET Reflector expected.

Expected version: "c:\temp\regen\System.Windows.dll"

Loaded version: "System.Windows.dll"

If the correct assembly is not loaded, debugging may not work.
---------------------------
OK
---------------------------

If you are doing any Windows Phone development, the tool does not work for you. I imagine that this shortcoming will be addressed in the coming months—the SDK was only recently released.

Other things I noticed

The source code gets dropped into an AppData folder. For example, the code for MS.Internal.CoreInvokeHandler is at:

C:\Users\Scott Seely\AppData\Local\Red Gate\.NET Reflector 6\Cache\V4\x86\CS\V35\c46bf0b4-91fb-4aa9-8732-63fe4e8d7afc\MS\Internal\CoreInvokeHandler.cs

Looking in the v35 directory, we see that a PDB is dumped out:

The assemblyLoc file corresponding to the System.Windows.PDB file has the following contents:

c:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\Silverlight\v4.0\System.Windows.dll

For an assembly in the GAC, System.Windows.Forms, the assemblyLoc file points to it’s GAC location:

C:\Windows\Microsoft.Net\assembly\GAC_MSIL\System.Windows.Forms\v4.0_4.0.0.0__b77a5c561934e089\System.Windows.Forms.dll

which appears to say that the symbols are generated from that particular reference assembly. The GUID named folder contains source code.

Summary

Having access to source and single stepping helps me troubleshoot problems faster because I can see why the underlying code doesn’t like what I’m doing when consuming the class libraries. Like most developer tools, this one has its value in the time savings you will get by getting you to the why of a bug in less time. I like the tool because it doesn’t change how I do my day job. It gives me access to more code so I can poke down the debug path even further without pulling out Reflector to grok why my code isn’t behaving as expected. And, I can easily make stepping into other people’s code part of my daily workflow.

Overall, I like the enhancements and am looking forward to using .NET Reflector Pro.

Versioning REST Services

2010-03-13T19:01:00Z

I’ve always been intrigued by the versioning problem. The versioning problem works like this: you build an API (Application Programming Interface) to get some work done. That API is successful and consumers ask for enhancements to the API. At this point, you have a problem: how do you support everyone who uses the current API while adding enhancements? If you have been down this road, you know that you have to solve the problem early—before success.

The way you handle versioning varies. With compiled code and libraries, you send out a new DLL/Assembly/JAR file and tell folks to convert existing code when they have a chance. With Web services, including SOAP, REST, and just HTTP accessible ones, you have other issues. You typically want a single code base to consume the old and updated messages. Given that many of us are now writing REST services, I talked to InformIT about the need for an article explaining how to version these JSON/XML speaking endpoints. That article is now live and available for your reading at http://www.informit.com/articles/article.aspx?p=1566460.

I’m such a friggin idiot—Day of Mobile has that Jay Freeman!

2010-02-27T01:17:00Z

I’m hosting a conference in Chicago called Day of Mobile. At the end of the day, we are having a big time keynote from Jay Freeman. These days, he’s a rock star in the iPhone universe. For some reason, and I’m a complete moron for not realizing this until a few minutes ago, he is the same guy who brought the .NET world this little tool: Anakrino. If you are scratching your head and wondering why that would impress me, it’s because I’m getting older and I’ve used every .NET tool in the world. Anakrino was a mainstay at Microsoft to decompile .NET assemblies to read in C# and VB.NET. It was easier to use than grabbing the source code. Eventually, the tool found a home at RedGate and is now called .NET Reflector. [edit: Apparently, my memory is poor at times too. As a commenter so kindly pointed out, Lutz Roeder wrote Reflector, at one time a competitor of Anakrino.]

So, in the last few minutes, I’ve gone from realizing that we had a really awesome iPhone ninja speaking at the conference to realizing that we had one of those legendary brainiac developers at the conference. And, while I didn’t want to pimp the conference at devlicio.us, I now feel I should because he’s such a part of all of our everyday lives as .NET developers. I mean, the guy who single handedly wrote Anakrino/.NET Reflector. Holy friggin’ crap!

Visual Studio 2010 Beta-->RC install and ASP.NET

2010-02-10T14:31:00Z

I installed the VS 2010 RC last night, after uninstalling the VS 2010 Beta. If you see that ASP.NET isn’t coming up/working on your machine, you may need to remap the ASP.NET handlers into IIS. To do that, go to the Microsoft.NET 4.0 folder on your machine (typically C:\Windows\Microsoft.NET\Framework64\v4.0.30128 on a 64-bit Windows install, C:\Windows\Microsoft.NET\Framework\v4.0.30128 on a 32-bit install). Once in that folder, run the following:

aspnet_regiis.exe –i

After doing this, your ASP.NET applications should start running again. This is the same trick that worked on earlier versions of .NET, but it’s been a while since we had a .NET upgrade. I thought this might help out a few of you out there.

DataContract, Partial Types and Generated Code

2010-02-09T19:31:00Z

The other day, a friend had an issue with a DataContract. He had an Entity Model that used DataContract serialization. The code, stripped down to its essence, had something like this:

[DataContract]
public partial class SomeClass
{
    [DataMember]
    public int MyInt { get; set; }
}

And this was all well and good. When transmitting SomeClass over the wire, the fields on the entity model were transmitted. Now, my friend is really smart, and he knew that his version of serialization had implicit serialization. So, when adding new fields, he relied on implicit field serialization by augmenting SomeClass in a separate file as:

public partial class SomeClass
{
    public string MyString { get; set; }
}

Lo and behold, the field MyString didn’t appear on the wire. Why was this? This is because partial classes are a compiler trick that hides itself at the assembly level. The assembly indicated that SomeClass is a type that has the following C# implementation:

[DataContract]
public partial class SomeClass
{
    [DataMember]
    public int MyInt { get; set; }

    public string MyString { get; set; }
}

This shows that MyString is not part of the data contract, so the field doesn’t get serialized. At the assembly level, no one knows that you separated the implementation across two files.

So, next time you are wondering why part of your object isn’t being serialized, see if you made any declarations about serialization on the type. If you did, you have turned off the automatic “magic” parts of serialization. Sometimes, wizards will make those decisions for you. One way to recognize that the work was done for you: look to see if the generated type has [DataContract] on the partial class you are augmenting.

Incorporating Video into a Silverlight 4 Application

2010-01-25T12:00:00Z

Over the past week, I spent some time with Silverlight 4. I’m really impressed by how easy it is to incorporate video into an application. This post shows how to capture video from the camera and display the video on the screen. The post also handles grabbing single frames of video. You might use this type of arrangement to allow users to upload images, hold impromptu web casts, and to do video conferencing.

I’ve uploaded a barebones application that turns on video capture and displays the video (viewable here)

To understand how this works, you need to be familiar with the following objects:

CaptureSource

CaptureDeviceConfiguration

VideoBrush

The CaptureSource type encapsulates the methods needed to interact with audio and video devices.

CaptureDeviceConfiguration acts as gatekeeper to the webcam and microphone. CaptureDeviceConfiguration knows how to ask the user for permission to use the webcam or microphone. It also remembers what the user said about using the webcam or microphone during the current session.

VideoBrush knows how to paint using a video as the source.

In order to interact with the camera, you need to know whether the user gave you permission and if not, you have to ask for permission. Once you have permission, you just need to capture video from the default camera, create the brush, and start capturing the video.

private CaptureSource _captureSource = null;
private void btnStartCapture_Click(object sender, RoutedEventArgs e)
{
    if (_captureSource != null &&

        _captureSource.State == CaptureState.Started)
    {
        return;
    }
    if(!CaptureDeviceConfiguration.AllowedDeviceAccess)
    {
        if(!CaptureDeviceConfiguration.RequestDeviceAccess())
        {
            return;
        }
    }

    _captureSource = new CaptureSource
       {
         VideoCaptureDevice =

           CaptureDeviceConfiguration.GetDefaultVideoCaptureDevice()
       };
    var brush = new VideoBrush();
    brush.SetSource(_captureSource);
    _captureSource.Start();
    rectVideo.Fill = brush;
}

Later on, when the user wants to capture the current video as an image, you just do something like this to put the current frame into an image control:

private void btnGrabImage_Click(object sender, RoutedEventArgs e)
{
    if(_captureSource == null || _captureSource.State != CaptureState.Started)
    {
        return;
    }
    _captureSource.AsyncCaptureImage(
        image => imgCapture.Source = image
        );
}

As someone who spent way too much time in the C++/MFC era writing code to capture video from devices, I am incredibly impressed with the brevity of the code. I think the SL4 team did an awesome job here. Way to go!

You can grab the sample project here.

The Sieve of Eratosthenes and F#

2009-12-19T03:42:00Z

There is a problem on the Euler project, www.projecteuler.net, which asks to find the sum of all values under a given number. Problems on the Euler project have a range of solutions, where at least one solution has a runtime of under 1 minute. A popular, time efficient algorithm that finds all primes in a given range is the Sieve of Eratosthenes. The basic algorithm is:

Create an array that contains all values from 2 up to the final maximum value
Starting at 2, For each value in the array, mark all items that have indices of the current value that are multiples and NOT equivalent to the current index as 0 (eg. index mod [current value] == 0).
March forward until you hit a non-zero value in the array, then mark all multiples as 0.
Halt condition: stop when you cross the midpoint of the array (anything remaining that is non-zero is a prime since you already all multiples of 2).

In practice, this gives successive iterations of an array from 2 .. 10 as:

[2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 3, 0, 5, 0, 7, 0, 9, 0]
[2, 3, 0, 5, 0, 7, 0, 0, 0]
At this point, we reach 5, which is greater than the length of the array (9) divided by 2 (4.5). Any non-zero values in the array are prime.

In C#, one possible implementation is:

private static long SieveOfErastosthenes(long maxvalue)
{
    long[] values = new long[maxvalue];
    // Populate the list
    for (long i = 0; i < values.LongLength; ++i)
    {
        values[i] = i;
    }
    values[0] = 0;
    values[1] = 0;
    for (long i = 2; i < values.LongLength; ++i)
    {
        if (values[i] != 0)
        {
            for (long j = i * 2; j < values.LongLength; j += i)
            {
                values[j] = 0;
            }
        }
    }

    long retval = 0;
    foreach (long k in values)
    {
        retval += k;
    }
    return retval;
}

Overall computational complexity is O(n). If you aren’t familiar with big O notation, the overall complexity is bound by the size of the dataset times a constant—in this case 3, since we iterate through the complete dataset 3 times:

Populate the dataset
Mark all non primes as 0
Sum the primes

And yes, this works quite well, even for large values of n. My challenge was to get the sieve to work with performance equal to C#, only in F#. At the start of this, I had my first pass of the C# code running in ~600 ms for a value of 5 million. The challenge I set for myself was to achieve a similar timing in F#. The first few passes left me with runtimes of over 15 minutes (I killed the runs prior to completion). The reason why was simple: I wrote an O(n^3) algorithm. My challenge was to get this faster without using mutable values. My first pass looked like this:

let rec sieveofErastosthenes values filterout maxval =
    if (filterout >= (maxval/2)) then
        values
    else
        let shouldFilter =
            try
                let a = values |> List.find(fun x -> x = filterout)
                a <> 0
            with
            | _ as ex -> false
        if (shouldFilter) then
            sieveofErastosthenes (values 
                |> List.filter(fun x -> (x = filterout) || ((x % filterout) <> 0))) (filterout + 1) maxval
        else
            sieveofErastosthenes values (values |> List.find(fun x -> x > filterout)) maxval

let max = 5000000
let sumofprimes =  sieveofErastosthenes [2 .. max] 2 max |> List.map( fun x -> int64 x) |> List.sum

This code is correct—pass in 10 for the max and the value returned is 17. But the answer just never returned for larger values within reasonable time. Next, I tried using a mutable type: System.Collections.Generic.List<T>. This got the time down to a measureable 4s. That’s still 6.5x longer than the C# version. That next attempt looks like this:

let sieveOfEratosthenes x =
    let retval = new List<int32>()
    retval.AddRange([0 .. x])
    retval.Item(0) <- 0
    retval.Item(1) <- 0
    for i in 2 .. x do
        if retval.Item(i) <> 0 then
            for j in 2 * i .. i .. x do
                retval.Item(j) <- 0
    retval.ToArray()

let max = 5000000
let sumofprimes =  sieveOfEratosthenes max |> Seq.map( fun x -> int64 x) |> Seq.sum
printfn "%A\n" sumofprimes

Notice that this latest iteration executes a lot less code and, frankly, looks pretty close to the C# code. Through some investigation, I found that the call to preload the array consumed 2.6 s. I then switched to a sequence and shrank the execution time to 2300 ms. I was closing in on my goal and learning some stuff about the performance of various F# constructs. Loading using a sequence changed the AddRange call to this:

retval.AddRange([|0 .. x|])

The reason this takes less time is simple. When allocating a List, F# allocates and initializes all values up front. The Seq is created with an iterator and only allocates enough space to store the iterator and not much else. So far, so good. At this point, I did a search on F# implementations of the Sieve of Eratosthenes and found that Chris Smith had one. His implementation keeps track of which numbers AREN’T prime. Performance on his algorithm hits 8600 ms. That wound up being a step in the wrong direction.

Next, I tried, explicitly initializing the list of integers and cut the time down to 1450 ms. The strategy was getting me closer to optimal timing and showed that, for 5 million int32s, I was filling in the list in 46 ms.

let sieveOfEratosthenes x =
    let retval = new List<int32>(x + 1)
    for i in 0 .. x do retval.Add(i)

    retval.Item(0) <- 0
    retval.Item(1) <- 0
    for i in 2 .. x do
        if retval.Item(i) <> 0 then
            for j in 2 * i .. i .. x do
                retval.Item(j) <- 0
    retval |> Seq.filter(fun x -> x <> 0)

This was better, but I’d like to get closer to the C# version. The last thing I tried was moving to Array from System.Collections.Generic.List. This last change cut 250 ms, bringing my times down to 1200 ms. It looks like using lighter weight objects really will speed things up! That version is:

let sieveOfEratosthenes x =
    let retval = Array.zeroCreate(x + 1)
    for i in 0 .. x do retval.[i] <- i
    retval.[0] <- 0
    retval.[1] <- 0
    for i in 2 .. x do
        if (i % 2 <> 0) && retval.[i] <> 0 then
            for j in 2 * i .. i .. x do
                retval.[j] <- 0

    retval |> Seq.filter(fun x -> x <> 0)

let max = 5000000
let sumofprimes =  sieveOfEratosthenes max |> Seq.map( fun x -> int64 x) |> Seq.sum

Greatest Prime Factor in F#

2009-12-17T00:00:00Z

Today I was reading an article in The Onion, Conquerors You May Have Missed, and noticed that the number for the ant looked like it might be a big old prime, or at least have a large prime divisor. (For reference, the ant is # 43,168,974,563,247.) There are a number of algorithms for finding this answer, but my favorite is a little brute force algorithm that keeps dividing the big number by some other value until the two numbers are equal. Yes, I know I can short circuit a bunch of testing via a square root function, but BigInteger doesn’t have a sqrt function (yet…).

Anyhow, I cobbled this together and it worked right out of the gate:

let rec largestFactor x y = 
    if (x = y) then y
    else
        let z = x % y
        if z = 0I then largestFactor (x/y) y
        else largestFactor x (y + 1I)

let LargestPrime x = largestFactor x 2I

let a = LargestPrime 43168974563247I

printf "%A" a

Answer: 84,826,177

So, the number isn’t prime, but the largest prime factor is pretty big! And, writing up the code to figure out the answer itself was pretty simple.

Slides and Code from Chicago Alt.NET meeting

2009-11-12T15:00:00Z

I want to say thanks to everyone who came out to watch me speak about OpenSocial at the Chicago Alt.NET meeting. Thanks for inviting me to present and for making the time so enjoyable. I’ve posted the slides and the code for the Canvas page here.

Speaking at Chicago Alt.Net Meeting

2009-11-10T02:25:00Z

This month, I’ll be speaking at the Chicago Alt.Net user group meeting. Please check out the details here and register here. And, here is the blurb on the talk:

November 2009 Meeting

Building OpenSocial Applications

6:00 pm
Pizza and networking time

6:30 pm

From its official web site:

Friends are fun, but they're only on some websites. OpenSocial helps these sites share their social data with the web. Applications that use the OpenSocial APIs can be embedded within a social network itself, or access a site's social data from anywhere on the web.

OpenSocial is the platform that MySpace, Orkut, Ning, LinkedIn, Hi5, and pretty much every social network but Facebook supports for creating games and other applications that run on these social network sites.

In this talk, we focus on the MySpace platform and how one builds a MySpace application. This involves interacting with the OpenSocial JavaScript as well as receiving and sending OpenSocial requests on your own servers.

Iowa Code Camp November 2009 Slides Up

2009-11-08T00:39:00Z

I want to send out a big thank you to the team who put together the Iowa Code Camp. You people did an awesome job!!! I had a great time giving my talks and really enjoyed hanging out with the crowd in Iowa.

For those of you who attended my talks, or just want to see the materials, I’ve posted things.

WCF Diagnostics Talk and Materials

WinDBG Talk and Materials

See you next year…

Speaking at nPlus1 ArcSummit- Chicago

2009-11-02T13:18:00Z

On December 7, I’ll be speaking at the nPlus1 ArcSummit for the optional morning session. I’d love to see the place packed! Here are the details:

https://www.clicktoattend.com/invitation.aspx?code=142763

About nPlus1.org

nPlus1.org is a site dedicated to helping Architects, aspiring Architects and Lead Developers learn, connect and contribute. On this site you’ll have access to great first party content written by some of the most skilled and experienced Architects working today. You’ll also have access to, and be able to contribute to a nexus of content from around the Internet aimed at keeping Architects up to date on all the new developments in their fields of interest.

When

Monday December 7, 2009 – 10:00PM to 5:00PM

Where

Microsoft MTC - Aon Center

200 E. Randolph

Suite 200

Chicago, IL 60601

driving directions

Free Lunch Provided

Agenda

Morning Session (Optional): An Introduction to Object Oriented Programming

10:00 AM - 12:00 PM

Are you new to OOP? Do you want a refresher on the benefits of Interfaces and the differences between implements and extends? The morning session is a two hour introductory course of Object Oriented Programming. If you are new to OOP the lessons in this session will prepare you for the more advanced topics in the afternoon.

If you are already well versed in OOP then feel free to come have a refresher, or simply join us for lunch and the advanced sessions in the afternoon. The morning session is completely optional.

Afternoon sessions:

Session One: Software Patterns

Patterns are an important tool to use as architects and developers. They provide a common vocabulary for us to design with, as well as a common approach to a common problem. Come learn about useful patterns, and how to use them in your everyday code.

Session Two: How I Learned To Love Dependency Injection

Dependency Injection is one of those scary topics that most developers avoid. It sounds all ‘high-falootin’ and complex. It’s not. Really. We wouldn’t lie. It’s a great way to manage complexity in your system, and a great way to make your system so much more testable. And isn’t that what we all want?

Each session will be followed by open discussions periods.

A catered lunch will be provided starting at noon. This will divide the morning introductory sessions from the advanced sessions. Register once for all session and choose to attend the morning, the afternoon or both! Lunch is provided for attendees for any of the sessions.

Lambdas aren’t just for managed code

2009-10-21T23:50:29Z

A long time ago, I was a C++ developer. I actually thought of myself as a pretty darn good C++ developer and got way too excited when I finally got to meet folks like Scott Meyers and actually landed a job working with Bobby Schmidt—same team on MSDN. (If you know Bobby’s name, well, you were pretty deep into C++ circa 1999.) Then, like many C++ devs, I moved over to a garbage collected language. I’ve done more than my fair share of professional .NET and Java development. C++ has been left by the wayside. Today, I finally downloaded and installed Visual Studio 2010 Beta 2. I dug into the “What’s New” and, out of curiosity, decided to look at C++ first (I already know about many of the C# and VB changes). I saw two cool things:

C++ now has an auto keyword. For you C# devs, it is pretty much the same as the C# var keyword.
C++ has lambdas.

Now, I’m only a little ways into understanding C++ lambdas, so some of my information here may be suspect. The C++ lambda is just an anonymous function. You can pass variables into the function so that the variable is visible within the function. The syntax is:

[ list of variables from current scope to pass into lambda scope ] return-type( function signature ) { code }

The canonical example appears to be std::for_each from <algorithm>.

   #include "stdafx.h"      
#include <iostream>       
#include <algorithm>       
#include <vector>       
using namespace std; 
    int _tmain(int argc, _TCHAR* argv[])      
{       
    vector<int> myints;       
    for (auto i = 0; i < 10; ++i){       
        myints.push_back(i);       
    }       
    auto number = 0;       
    auto numSquared = 0;       
    for_each(myints.begin(), myints.end(), [&number, &numSquared](int n) {  
        cout << n << endl;       
        number += n;       
        numSquared += n * n;       
    });       
    cout << "The sum is " << number << endl;       
    cout << "The sum of the squares is " << numSquared << endl;       
    return 0;       
}

In this example, I have two values: number and numSquared. I make references of the value visible to the lambda, which prints out each value as it comes through and then sums the numbers and their squares. Once the function completes, the code emits the values to the console window. If you don’t want to pass anything to the lambda, you still need to state this. If I didn’t want number or numSquared visible, the lambda signature would be:

   [](int n){}

At some point, I’ll dig in and see what else this is good for, including how to build my own Functor signatures. Anyhow, just thought I’d share this little nugget with you.

New F#/WCF Article up at InformIT

2009-09-30T19:10:00Z

My article on programming REST services with F# and WCF went up at InformIT. Please go read it! http://www.informit.com/articles/article.aspx?p=1394625

Review of ANTS Memory Profiler

2009-08-23T16:05:00Z

Quick Summary: Highly recommended! This is a big time saver over WinDBG/SOS/CLRProfiler. Either combination will get the job done, but you will complete simple tasks in significantly less time if you choose ANTS Memory Profiler.

The review

Our sponsors over at Red Gate Software released a new version of their Memory Profiler and asked devlicio.us to give it a spin and write up a review. I had never used the tool before, but I have used the standard Microsoft tools to troubleshoot memory issues. My biggest concern with the Red Gate product is not whether it works but if it is worth the price in terms of time saved and productivity. With a list price of US$495 for the standalone product or US$795 for the .NET Bundle, it needs to save a lot of time to be worth the money. To get a feel for how it compares to the Microsoft solution, I decided to run Tess Ferrandez’s .NET Debugging labs 3 and 6 against the Red Gate Memory Profiler. In my evaluation, I’m mostly interested in seeing if I can get to all the data and find the planted bugs without spinning up WinDBG + the SOS CLR extension, AdPlus, and all those other tools.

Setup

My test system is a Dell Studio XPS M13 with 4GB RAM running Windows 7 Ultimate x64.

I installed the 14 day trial of the .NET Bundle. When you download, you will get an email from someone at Red Gate asking how they can help you with your evaluation and reminding you that there are demos and exercises to learn the tool at the bottom of the Memory Profiler home page. I then ran through the demos and labs to get familiar with how the Memory Profiler tool works.

To recreate the problem scenarios, I used Tinyget from the IIS 6.0 Resource Kit Tools.

For setup, I grabbed the BuggyBits.zip file and unzipped it into c:\inetput\wwwroot\BuggyBits. I then opened up Internet Information Services (IIS) Manager, navigated to and right-clicked on the BuggyBits folder, and selected Convert to Application.

Debugging .NET Debugging Demos Lab 3: Memory

This lab stresses a web site and causes a high memory situation. The lab has a simple goal: figure out what caused the issue memory leak. I setup the Memory Profiler to run the BuggyBits application. One thing I ran into was that the profiler won’t actually start profiling until you navigate to another page in the IIS application. For BuggyBits, this meant navigating to http://localhost/BuggyBits/Links.aspx in order to start profiling. I then followed these steps:

Take Memory Snapshot
From a command line, ran tinyget -srv:localhost -uri:/BuggyBits/Links.aspx -loop:400
Took another Memory Snapshot
Started my investigation

I did find that if I ran the application in a loop of 4000 items, Memory Profiler ran into memory issues during the investigation. That said, it was easy enough to do the troubleshooting with a smaller repro case.

The first screen I saw after taking the second snapshot is this:

From that, we can see that we have a lot of strings, but we also have two classes with very similar instance counts: StringBuilder and Link. StringBuilder is a .NET CLR type, but Link isn’t. From this same screen, we can also take a look at how many objects are on the Gen 0,1, and 2 heaps. Looking at the Gen 2 heap, we see a similar picture with 3505 Link objects on the heap. What is causing the number of Link objects to be so high? Looking at the source, we see a class with a finalizer declared—the finalizer does some heavy work (simulated via Thread.Sleep):

~Link()
{
    //some long running operation when cleaning up the data
    Thread.Sleep(5000);
}

At this point, we have a few things we can do to fix the code:

Eliminate the finalizer altogether.
Implement IDisposable and make sure to explicitly Dispose any Link objects after they are used.

I tried both options, and saw that we stopped leaking Link onto any of the heaps.

Discovery in this case was pretty simple as the first screen gave me enough data, via the increase in memory usage on the graph and the analysis to know what was going on as well as inform me if my changes helped.

Debugging .NET Debugging Demos Lab 6:_Memory Leak

Another memory leak situation. I followed a similar setup to the previous example. Steps to gather data are:

Navigate to http://localhost/BuggyBits/ProductInfo.aspx?ProductName=Bugspray
Take Memory Snapshot
From a command line, ran tinyget -srv:localhost -uri:/BuggyBits/ProductInfo.aspx?ProductName=Bugspray –threads:50 -loop:20
Took another Memory Snapshot
Started my investigation

This time, I was greeted by the following summary:

A large growth in strings still isn’t interesting. This grows due to assemblies being loaded in between calls and is hard to pin as an issue. Looking at “Largest Growth in Instances”, I see that RuntimeType has grown by quite a bit. Let’s see why. I clicked on RuntimeType and saw this screen, showing me how the size had changed:

I then selected the Class Reference Explorer and got a hint as to what is going on:

While it doesn’t consume much space, the big hint of System.Xml.Serialization.TypeDesc is enough of a hint that we might have a serialization issue. XmlSerialization generates new assemblies when certain constructors are run. One feature I particularly liked in this investigation was the ability to see what types of objects were holding onto the references of other types. Here is an example of the objects referring to our TypeDesc.

From here, I looked for uses of XmlSerializer and sure enough, found one of the versions that doesn’t cache the serializer. DataLayer.cs contains these lines:

  118         Type[] extraTypes = new Type[1];
  119         extraTypes[0] = typeof(ShippingInfo);
  120 
  121         MemoryStream ms = new MemoryStream();
  122         XmlSerializer xs = new XmlSerializer(typeof(Product), extraTypes);
  123         xs.Serialize(ms, p);

This is one of the constructors that creates a new assembly for every XmlSerializer instance. To fix the issue, one should cache the serializer. I did so by creating a static property on the DataLayer class:

    static XmlSerializer _xs = null;
    static object _xsLock = new object();
    static XmlSerializer Serializer
    {
        get
        {
            if (_xs == null)
            {
                lock (_xsLock)
                {
                    if (_xs == null)
                    {
                        Type[] extraTypes = new Type[1];
                        extraTypes[0] = typeof(ShippingInfo);
                        _xs = new XmlSerializer(typeof(Product), extraTypes);
                    }
                }
            }
            return _xs;
        }
    }

This sped up execution time and reduced the number of RuntimeType instances by 2,031.

Other Impressions

Given the speed with which I could diagnose the above two issues, I was really impressed. I also loved the ability to dig around and see what classes were in use and track through object graphs. To get the same job done with the Microsoft SDK tools I would have to correlate information from WinDBG + SOS and from CLRProfiler. The fact that I could do all this drill down in one tool gave me a huge productivity boost.

I did have some issues with using the profiler. I posted the issue to the Red Gate forum and had a resolution within a few days. It turned out due to the design of the Server Garbage Collector (the GC that runs on multi-core machines) has a behavior that may appear as memory corruption to a profiler. (You can read the forum thread here.) I had a few other interactions with Red Gate as well and found the company to be very responsive to my needs. Because of the way the tool presents information, I could see patterns quickly and fix the issues with ease. Thanks to the time saving properties, I heartily recommend buying at least one copy of the Memory Profiler for every dev team. This is something I will be using once per sprint to look for memory leaks.