This, That & Technology

The performance impact of querying IEnumerable

2012-02-16T08:16:00.001-05:00

We are constantly reminded in technical articles, presentations and blogs about the performance impact IEnumerable<T> can have if you do not pay close attention to how the underlying type of the object you are querying or enumerating over got created.

Multiple Enumeration of LINQ results

Multiple enumeration of IEnumerable

Resharper: Possible Multiple Enumeration of IEnumerable

The statement that creates the IEnumerable<T> is not executed at the time of creation. Instead, it’s executed when a statement uses the IEnumerable<T> (lazy loading or delayed execution).

Since I have always been conscious of this and avoided having the IEnumerable<T> be executed multiple times. I have never experienced the situation where the code using the IEnumerable<T> has been affected negatively (at least what I’m aware of). I have also never come across an article or a blog that illustrates this behavior backed by either SQL profiler trace data or profiled code statistics.

Recently however, I was adding some functionality to MVC controller function that performed some LINQ queries on the IEnumerable<T>. I was disappointed at the performance degradation I experienced when I started testing the view. This function has been extended over time, an one eventually loses focus on where and how data structures get created. After going through the action code carefully, I noticed that the IEnumerable<t> was not converted to a concrete list at creation time. Adding “.ToList()” to the statement that created the IEnumerable<T> improved the performance drastically.

Following is a very simplistic sample backed by profiler data on what exactly is happening. I used an evaluation copy of dotTRACE 4.5 from JetBrains (a pretty cool profiler that requires minimalistic configuration and produces great profiling data to help you understand the inner workings of your application).

The sample code looks like this:

        1: var nums = Enumerable.Range(0, 100000)

       2:     .Select(n => new Nums { Id = n, Name = n.ToString() });

       3:  

       4: var nums1 = nums.Where(n => n.Id < 10000);

       5: var nums2 = nums.Where(n => n.Id >= 10000 && n.Id < 50000);

       6: var nums3 = nums.Where(n => n.Id >= 50000);

       7:  

       8: nums1.ToList().ForEach(n => n.Name += "1");

       9: nums2.ToList().ForEach(n => n.Name += "2");

      10: nums3.ToList().ForEach(n => n.Name += "3");

Line 1 creates an IEnumerable<Nums>. Line 4,5 and 6 create some new IEnumerables<Nums> based on some filter criteria and lines 8, 9 and 10 manipulate the Name property of all Nums instance within the filtered IEnumrable<Nums>. If we profile the above code, guess how many times line 1 will gets executed?

Line 1 gets executed 300,000 times, once for each of line 4, 5, and 6. The best way to avoid this is to force IEnumerable<Nums> to be a concrete type created at the time it’s defined by calling the “.ToList” function. This drastically changes the behavior of IEnumerable<T> since it’s been loaded (also know as eager loading) and any additional commands executed will not cause the IEnumerable<T> to execute again.

Since I added “.ToList” to line 1, it now only executes 100,000 times at the time of creation, irrespective of the filtering been applied in line 4, 5, and 6. The performance impact can clearly be seen in the profiled code. Example 1 ran in 16,409 ms whereas example 2 ran 10,405 ms.

If I was to define nums in line 1 as IEnumerable<Nums>, it still only executes 100,000 times since the “.ToList” creates a concrete list at creation time.

       1: IEnumerable<Nums> nums = Enumerable.Range(0, 100000)

       2:     .Select(n => new Nums { Id = n, Name = n.ToString() }).ToList();

Remap your keyboard

2012-02-03T22:15:00.001-05:00

I just started a new job and was provided a Dell Latitude E6420 as my work machine. It’s a great machine and the performance is super fast. With quad core dual thread i7, 8 GB memory and a 256 GB SSD, what more could I ask for? A better keyboard layout comes to mind!

I’m not one of those 10 finger typers that don’t even have to look at the keyboard when writing code or taking notes. I’m a 5 finger typer that constantly has to look at the keyboard while typing. The only time I do not have to bother looking (o joy!) is when I use the arrow keys, which is mostly located bottom left on a keyboard.

Imagine my frustration when I noticed that the home and end buttons on my new machine do not live in close proximity with my arrow keys. NO! They now live in the top right hand side of the keyboard about 4 keys in. Not easy keys to find for me unless I look at the keyboard. The page up and page down keys have instead taken the convenient slots of what should have been (at least for me) the home and end buttons.

So with some hesitation on my end, I figured it would just be a matter of time before I get use to the layout and life will be great again. However, the opposite is happening. I am getting more and more frustrated every time I push the page up button while actually just wanting to go to the beginning of the line. It’s disturbingly interruptive because now I have not even move to the beginning of the line, but also moved way off my current editing spot in code and have to get back and find the home and end keys.

After 3 days of dealing with this, I’ve decided to find a way to re-map my key and swap the home with the page up and end with the page down keys. There are various 3’rd party utilities that can do this for you, but I found this great article that shows you exactly which registry setting to set and what values to set in order to re-map your keyboard keys. My registry setting to swap my keys is "Scancode Map"=hex:00,00,00,00,00,00,00,00,05,00,00,00,47,e0,49,e0,4f,e0,51,e0,49,e0,47,e0,51,e0,4f,e0,00,00,00,00

After logging back into Windows 7, it now works like a charm. Now I need a sharpie to physically fix the keyboard keys too .

The performance impact of querying IEnumerable

2012-01-31T16:00:00.001-05:00

Multiple Enumeration of LINQ results

Multiple enumeration of IEnumerable

Resharper: Possible Multiple Enumeration of IEnumerable

The statement that creates the IEnumerable<T> is not executed at the time of creation. Instead, it’s executed when a statement uses the IEnumerable<T> (lazy loading or delayed execution).

Since I have always been conscious of this and avoided having the IEnumerable<T> be executed multiple times. I have never experienced the situation there the code using the IEnumerable<T> has been affected negatively (at least what I’m aware of). I have also never come across an article or a blog that illustrates this behavior backed by either SQL profiler trace data or profiled code statistics.

The sample code looks like this:

        1: var nums = Enumerable.Range(0, 100000)

       2:     .Select(n => new Nums { Id = n, Name = n.ToString() });

       3:  

       4: var nums1 = nums.Where(n => n.Id < 10000);

       5: var nums2 = nums.Where(n => n.Id >= 10000 && n.Id < 50000);

       6: var nums3 = nums.Where(n => n.Id >= 50000);

       7:  

       8: nums1.ToList().ForEach(n => n.Name += "1");

       9: nums2.ToList().ForEach(n => n.Name += "2");

      10: nums3.ToList().ForEach(n => n.Name += "3");

If I was to define nums in line 1 as IEnumerable<Nums>, it still only executes 100,000 times since the “.ToList” creates a concrete list at creation time.

       1: IEnumerable<Nums> nums = Enumerable.Range(0, 100000)

       2:     .Select(n => new Nums { Id = n, Name = n.ToString() }).ToList();

Rounding differences between browser versions

2012-01-17T23:10:00.006-05:00

Working on a client mobile site that does dynamic page layout utilizing every pixel in an attempt to maximize real estate usage. I primarily use Chrome as my default browser and then test on IE, Opera and Firefox as needed. Today I burnt some cycles trying to debug why my layout on IE and Firefox was not working out for me. I eventually traced it down to rounding difference between the browser versions.
Take the following sample HTML:

   1: <div id="divTest" style="width: 123.5px;">   2:     Hallo   3: </div>

Notice how the width of the div element is set to “123.5px”.
Using the following java script:

   1: alert($("#divTest").outerWidth());

The script will display the “outerWidth” of the div element. Running this on Chrome and Opera, I get a length of “123” and on IE and Firefox I get “124”. Reason I get integer is because the jQuery “outerWidth()” function returns an integer. So rounding is expected. However, the rounding differences between the browsers sure make a difference when trying to do dynamic layouts at the pixel level.
Try the JS Fiddle sample in the different browsers.
A quick workaround I used is to subtract “0.5” from “outerWidth”. This way at least I lose 1 or 2 pixels in my layout vs. the opposite spectrum of my layout not fitting into the page width at all.

Solving the shortcomings of HTML word-break and ellipsis for fixed size elements.

2011-11-21T15:40:00.001-05:00

Recently I have had to deal with a requirement that required word-break and ellipsis behavior on a multi-lined fixed size element. HTML does provide styling that will do:

Word-break for a multi-lined element.

See http://www.css3.com/css-word-break/

Ellipsis for a single lined element who’s content exceeds the element’s width.

See http://www.css3.com/css-text-overflow/.

Each of these styles work when used individually in conjunction within the Text_Overflow style. However, I found it impossible when trying to combine the above styles in a multi-lined element so that:

A word would be split into the next line.
Any content exceeding the second line would be clipped.
If clipping occurred, an ellipsis would be injected at the end of the second line.

I’m sure and hoping this can either already be done (hopefully someone will point that out) or that CSS3 and HTML5 will provide this functionality eventually. Heck, there may already be a jQuery plug-in that provides this using Canvas and SVG.

What I eventually ended up with was a server side solution that dynamically generates images by drawing the text using WPF and a HTTP handler. Caching the images client side helps reduce requests to draw the same text over and over again.

This is what the end result of the implemented solution looks like.

Notice how the first 3 server names have wrapped to the next line and have an ellipsis at the end of the second line. The server name has a fixed width and height in order to preserve the layout so servers appear in a grid-like fashion.

Let’s take the very first server and have a look at the HTML for the server name:

   1:  <img id="menuiconname" src="/xxx/images.ashx?text=alongservernametotestwrappingspacing" alt="alongservernametotestwrappingspacing">

The server name is actually an image that has it’s source set to an HTTP handler. The source for the image handler:

   1:          public void ProcessRequest(HttpContext context)

   2:          {

   3:              int objectId = -1;

   4:              int imageId = -1;

   5:              ImageData imageData = null;

6:

   7:              //get image per object id

   8:              if (int.TryParse(context.Request["obj"], out objectId)) { imageData = UIProcess.GetImage(objectId: objectId); }

9:

  10:              //get image per image id

  11:              if (int.TryParse(context.Request["img"], out imageId)) { imageData = UIProcess.GetImage(imageId: imageId); }

12:

  13:              //get image for text

  14:              if (!string.IsNullOrEmpty(context.Request["text"])) { imageData = Utility.ConvertTextToImage(context.Request["text"]); }

15:

  16:              //write image

  17:              if (imageData != null)

  18:              {

  19:                  var freshness = new TimeSpan(0, Utility.CacheDuration, 0);

  20:                  context.Response.ContentType = GetContentType(imageData.ImageType);

  21:                  context.Response.Cache.SetExpires(DateTime.Now.Add(freshness));

  22:                  context.Response.Cache.SetMaxAge(freshness);

  23:                  context.Response.Cache.SetCacheability(HttpCacheability.Public);

  24:                  context.Response.Cache.SetValidUntilExpires(true);

  25:                  context.Response.Cache.SetVaryByCustom("*");

  26:                  context.Response.AddHeader("content-disposition", string.Format("inline; filename={0}.png", objectId));

  27:                  context.Response.BinaryWrite(imageData.Data);

  28:              }

29:

  30:              context.Response.Flush();

  31:          }

As you can see in line 14, a request is made to convert the text to an image. ImageData is a class that contains an image type (png, jpg, gif, bmp etc) and a byte array of the image. Once the image is generated the content type (line 20) and caching policy (line 21 – 25) is set . Finally the image is written to the HTTP pipeline (line 27).

Now the heart of the solution where the text gets converted to an image:

   1:          public static ImageData ConvertTextToImage(string value)

   2:          {

   3:              FormattedText formattedText = null;

   4:              string testValue = string.Empty;

   5:              int specialCharCnt = 0;

6:

   7:              //iterate each character to determine spacing of text to force wrap and word break

   8:              foreach (char character in value.ToCharArray())

   9:              {

  10:                  if (character == '-' || character == ' ') { specialCharCnt++; }     //ignore characters that cause line breaks

  11:                  else

  12:                  {

  13:                      testValue += character.ToString();

  14:                      formattedText = InitFormattedText(testValue);

15:

  16:                      //has the text length exceeded max length

  17:                      if (formattedText.Width < formattedText.MinWidth)

  18:                      {

  19:                          value = value.Insert(testValue.Length - (specialCharCnt == 0 ? 1 : 0), " ");     //keep special characters counted in mind

  20:                          break;

  21:                      }

  22:                  }

  23:              }

24:

  25:              //now for the real thing and save to PNG

  26:              ImageData imageData = new ImageData { ImageType = ImageType.Png };

  27:              formattedText = InitFormattedText(value);

  28:              DrawingVisual drawingVisual = new DrawingVisual();

  29:              DrawingContext drawingContext = drawingVisual.RenderOpen();

  30:              drawingContext.DrawText(formattedText, new Point(0, 0));

  31:              drawingContext.Close();

32:

  33:              RenderTargetBitmap bmp = new RenderTargetBitmap(95, 32, 120, 96, PixelFormats.Pbgra32);

  34:              bmp.Render(drawingVisual);

  35:              BitmapEncoder encoder = new PngBitmapEncoder();

36:

  37:              using (MemoryStream stream = new MemoryStream())

  38:              {

  39:                  encoder.Frames.Add(BitmapFrame.Create(bmp));

  40:                  encoder.Save(stream);

  41:                  imageData.Data = stream.ToArray();

  42:              }

43:

  44:              return imageData;

  45:          }

The solution uses the WPF FormatedText class. This class has built in intelligence for text wrapping and clipping. It also provides a wide array of properties that can be used to manipulate the way the text is drawn.

One issue I had to work around was to avoid that the control uses “soft-breaks” to break the word. Instead, I wanted to force where the word break occurs. To do this, I had to iterate through each character and eliminate “soft-break” characters - hyphens and spaces (line 10). While iterating each character, I would append the character and check the length(in pixels) of the word using the FormattedText class (line 17). Once the word length has exceeded the length of the control, I insert a “soft-break” (in this case a space) into the original text at the position the word will get clipped. This “soft-break” will then force a word break and the rest of the word will be drawn on the second line. Line 25 – 44 deals with drawing the text starting at position 0, 0 (line 30) and saving the rendered text to a PNG image (line 35) in a memory stream (line 37).

Line 14 and 27 call a function “InitFormattedText” that looks like:

   1:          private static FormattedText InitFormattedText(string value)

   2:          {

   3:              return new FormattedText(

   4:                  value,

   5:                  new CultureInfo("en-us"),

   6:                  FlowDirection.LeftToRight,

   7:                  new Typeface(new FontFamily("sans-serif"), FontStyles.Normal, FontWeights.Normal, new FontStretch()),

   8:                  11,

   9:                  new SolidColorBrush() { Color = Color.FromArgb(255, 84, 84, 84) })

  10:                  {

  11:                      MaxTextHeight = 32,

  12:                      MaxTextWidth = 75, //77,

  13:                      Trimming = TextTrimming.CharacterEllipsis,

  14:                      TextAlignment = TextAlignment.Center,

  15:                  };

  16:          }

This function basically initializes the FormattedText class (line 3), provides a font (line 7), a brush (line 9), sets the dimensions that the control needs to render the text into (line 11 – 12) and finally sets some alignment and trimming options (line 13 – 14).

This turned out to be a much more dynamic and flexible solution than trying to manipulate the HTML, styles and text (by injecting BR or WBR (which is not widely supported anyway)) to achieve the same result. It’s pretty impossible to set the max character width before injecting the BR since 10 wide characters takes up much more room than 10 narrow characters - “WWWWWWWWWW” vs. “IIIIIIIIII”. At least the FormattedText class calculates the word length in pixels making it easier to determine where a soft-break needs to be inserted.

Optimizing JavaScript for cacheability in MVC

2011-07-11T08:58:00.001-04:00

When I started with my current MVC mobile application, I had all my JavaScript embedded within the MVC views. The biggest reason was that there is embedded Razor within the script that got resolved server side once the view got rendered. For example getting and action url’s or setting a var to a value contained within the model.

The sample below is snippet of JavaScript that previously got embedded within a partial view.

   1:      <script type="text/javascript">

   2:          $(document).ready(function () {

   3:              //context actions menu

   4:              $("#contextactions").bind("vclick", function () {

   5:                  @if (!string.IsNullOrEmpty(Model.BeforeMenuDisplayFunctionName))

   6:                  {

   7:                      @(Model.BeforeMenuDisplayFunctionName + "();")

   8:                  }

   9:                  ShowContextActionsMenu();

  10:              });

11:

  12:              //action clicked

  13:              $(".contextactionitem").bind("vclick", function () {

  14:                  ContextActionClicked(this);

  15:                  return false;

  16:              });

Line # 5 and 7 shows some embedded Razor that gets a value from the model and uses that model (a function name in this case) if there is a value.

It’s pretty clear that this is not a very optimized way of serving up JavaScript, especially keeping in mind that mobile devices is target platform for this specific application. Bandwidth is “limited” on wireless compared to Wi-Fi and some folks may not have the privilege of “unlimited” data plans. Keeping these factors in mind, one has to consider alternatives to better ensure that bandwidth usage is minimized. One such option is client side caching of “static” files. This will prevent files already cached on the client (that have not changed) to be downloaded again.

The JavaScript shown above does not lend itself to caching since it has dynamic behavior based on the data in the model when the view gets rendered. What needs to be done is to get the JavaScript 100% static, and only embed the required data from the model within the view at render time. There are various options to do this:

Include the data in hidden HTML elements within the view.
JavaScript module pattern.
JavaScript singleton pattern.
JavaScript custom objects.
Others?

For a more in-depth explanation of the above patterns look at “JavaScript Programming Patterns” and “JavaScript Patterns” from Amazon.

The pattern I like the most in this specific scenario is the module pattern. It enables me to scope the model data better within views, partial views and helpers thereby minimizing any conflicts that may arise between all the moving parts that render HTML within a MVC application.

The JavaScript that now gets embedded within the view looks like the following.

   1:      <script type="text/javascript">

   2:          var dmMobileContextMenu = function ($) {

   3:              return {

   4:                  homeUrl: '@Url.Action("Index", "Home")',

   5:                  helpFileName: '@Model.HelpFileName',

   6:                  resolveHelpFileNameFunction: '@Model.ResolveHelpFileNameFunction',

   7:                  logoutUrl: '@Url.Action("Logout", "Account")',

   8:                  beforeMenuDisplayFunctionName: '@Model.BeforeMenuDisplayFunctionName',

   9:                  clickCallbackFunction: '@Model.ClickCallbackFunction'

  10:              };

  11:          } (jQuery);

  12:      </script>

  13:      <script type="text/javascript" src="@Url.Content("~/Scripts/Views/Shared/ContextMenu.js")"></script>

  14:  }

Notice in line #2 how the module pattern gets used to extract all the values from the view model into vars. Line # 13 includes the Javascript that got pulled off into a separate “.js” file.

The original JavaScript got moved to a separate “.js” file and changed to reference the module pattern variables rather than using embedded Razor. This means the JavaScript is 100% static and can be client side cached – thus eliminating the need to download it every time the view gets rendered.

   1:  $(document).ready(function () {

   2:      //context actions menu

   3:      $("#contextactions").bind("vclick", function () {

   4:          if (typeof dmMobileContextMenu.beforeMenuDisplayFunctionName == "function") {

   5:              window[dmMobileContextMenu.beforeMenuDisplayFunctionNametest]();

   6:          }

   7:          ShowContextActionsMenu();

   8:      });

9:

  10:      //action clicked

  11:      $(".contextactionitem").bind("vclick", function () {

  12:          ContextActionClicked(this);

  13:          return false;

  14:      });

Notice the changes in line # 4 and 5 that now access the vars declared using the module pattern.

Monitoring the traffic using “Fiddler”, one can clearly see that before the above change was applied, the page request was 11368 bytes. After the changes, the page was 9341 bytes. By making the JavaScript more cacheable resulted in a saving of 2027 bytes. On a single request his does not sound like much, but consider the scenario I have where this saving was on a partial view that gets used on every single other view within my application. This adds up over time.

Before:

After:

Enumerate all local websites within IIS 7

2011-06-20T11:14:00.001-04:00

There are various ways available to enumerate websites configured within IIS. The most common is to use the WMI Management BCL classes. However, if you are able to target IIS7, one is able to enumerate all websites within IIS using ServerManager class.

   1:              return new ServerManager()

   2:                  .Sites

   3:                  .GetCollection()

   4:                  .Select(s => s.GetAttributeValue("name").ToString()).ToList();

Enumerate all visible SQL Server instances

2011-06-20T11:06:00.001-04:00

An easy way to enumerate all visible SQL server instances on the network is to use SqlDataSourceEnumerator class.

   1:              //build server list

   2:              SqlDataSourceEnumerator instance = SqlDataSourceEnumerator.Instance;

   3:              System.Data.DataTable table = instance.GetDataSources();

4:

   5:              foreach (DataRow row in table.Rows)

   6:              {

   7:                  string serverName = row["ServerName"].ToString();

   8:                  if (!string.IsNullOrWhiteSpace(row["InstanceName"].ToString())) { serverName = string.Format("{0}\\{1}", serverName, row["InstanceName"]); }

   9:              }

Safely build your connection string using managed code

2011-06-20T11:02:00.001-04:00

Building up a connection string really is a no-brainer. Probably the most common way of building a connection string dynamically is using the StringBuilder class and concatenating all the required values for a Connection String. There are however a few handy string builder classes in the BCL. One I use often is SqlConnectionStringBuilder class.

   1:              //build connection string

   2:              SqlConnectionStringBuilder connection = new SqlConnectionStringBuilder

   3:              {

   4:                  DataSource = session["DATABASE_SERVER"],

   5:                  InitialCatalog = "master",

   6:                  ConnectTimeout = 30,

   7:                  IntegratedSecurity = string.Compare(session["CREATE_DATABASE_LOGON_TYPE"], "WinAuthCurrentUser") == 0,

   8:                  UserID = session["CREATE_DATABASE_USERNAME"],

   9:                  Password = session["CREATE_DATABASE_PASSWORD"],

  10:              };

  11:              return connection;

Validate port availability

2011-06-20T10:53:00.001-04:00

Ever wanted to validate whether a TCP port was already being listened on by a process. There are various ways that this can be done:

Use Telnet.
Physically try to connect to the port and handle the appropriate socket exceptions.
Use .Net BCL.

Option # 3 turned out to be pretty easy when combined with LINQ.

   1:  IPGlobalProperties ipProperties = IPGlobalProperties.GetIPGlobalProperties();

2:

   3:  if (ipProperties.GetActiveTcpListeners().ToList().Exists(ip => ip.Port == port))

   4:  {

   5:       //port is in use

   6:  }

Determine machine FQDN in .Net

2011-06-14T20:07:00.001-04:00

Amazing how much functionality the BCL provides. The Environment class provides a lot of very useful information about the current environment the code is running on. However, nothing about the machine’s FQDN. A quick call over to System.Net namespace will provide you with the FQDN (see line 4 below).

        1: static void Main(string[] args)

       2: {

       3:     Console.WriteLine(Environment.UserDomainName);

       4:     Console.WriteLine(System.Net.Dns.GetHostByName("LocalHost").HostName);

       5:     Console.ReadLine();

       6: }

Five most common regrets

2011-04-19T09:24:00.001-04:00

This post is a bit off the technology track, but a good read and some food for thought. My brother in law sent me this email. After reading it, it made me think about my past, where my future is heading and what (if anything) I should change.

“For many years I worked in palliative care. My patients were those who had gone home to die. Some incredibly special times were shared. I was with them for the last three to twelve weeks of their lives.
People grow a lot when they are faced with their own mortality. I learned never to underestimate someone's capacity for growth. Some changes were phenomenal. Each experienced a variety of emotions, as expected, denial, fear, anger, remorse, more denial and eventually acceptance. Every single patient found their peace before they departed though, every one of them.
When questioned about any regrets they had or anything they would do differently, common themes surfaced again and again. Here are the most common five:

I wish I'd had the courage to live a life true to myself, not the life others expected of me.
This was the most common regret of all. When people realize that their life is almost over and look back clearly on it, it is easy to see how many dreams have gone unfulfilled. Most people had not honored even a half of their dreams and had to die knowing that it was due to choices they had made, or not made.
It is very important to try and honor at least some of your dreams along the way. From the moment that you lose your health, it is too late. Health brings a freedom very few realize, until they no longer have it.

I wish I didn't work so hard.
This came from every male patient that I nursed. They missed their children's youth and their partner's companionship. Women also spoke of this regret. But as most were from an older generation, many of the female patients had not been breadwinners. All of the men I nursed deeply regretted spending so much of their lives on the treadmill of a work existence.
By simplifying your lifestyle and making conscious choices along the way, it is possible to not need the income that you think you do. And by creating more space in your life, you become happier and more open to new opportunities, ones more suited to your new lifestyle.

I wish I'd had the courage to express my feelings.
Many people suppressed their feelings in order to keep peace with others. As a result, they settled for a mediocre existence and never became who they were truly capable of becoming. Many developed illnesses relating to the bitterness and resentment they carried as a result.
We cannot control the reactions of others. However, although people may initially react when you change the way you are by speaking honestly, in the end it raises the relationship to a whole new and healthier level. Either that or it releases the unhealthy relationship from your life. Either way, you win.

I wish I had stayed in touch with my friends.
Often they would not truly realize the full benefits of old friends until their dying weeks and it was not always possible to track them down. Many had become so caught up in their own lives that they had let golden friendships slip by over the years. There were many deep regrets about not giving friendships the time and effort that they deserved. Everyone misses their friends when they are dying.
It is common for anyone in a busy lifestyle to let friendships slip. But when you are faced with your approaching death, the physical details of life fall away. People do want to get their financial affairs in order if possible. But it is not money or status that holds the true importance for them. They want to get things in order more for the benefit of those they love. Usually though, they are too ill and weary to ever manage this task. It all comes down to love and relationships in the end. That is all that remains in the final weeks, love and relationships.

I wish that I had let myself be happier.
This is a surprisingly common one. Many did not realize until the end that happiness is a choice. They had stayed stuck in old patterns and habits. The so-called 'comfort' of familiarity overflowed into their emotions, as well as their physical lives. Fear of change had them pretending to others, and to their selves, that they were content. When deep within, they longed to laugh properly and have silliness in their life again.

When you are on your deathbed, what others think of you is a long way from your mind. How wonderful to be able to let go and smile again, long before you are dying.”

LINQ Enabled Paging

2011-03-24T22:07:00.001-04:00

One has to love the power that LINQ brings to the table for developers. LINQ makes it very easy to page over an Enumerable using the “Skip” and “Take” commands. For example, consider the following code snippet:

        1: const int PAGESIZE = 10;

       2: static IEnumerable<int> numbers;

       3:  

       4: static void Main(string[] args)

       5: {

       6:     numbers = Enumerable.Range(1, 100);

       7:     PageNumbers(1);

       8:     Console.ReadLine();

       9: }

      10:  

      11: private static void PageNumbers(int pageNumber)

      12: {

      13:     numbers.Skip((pageNumber - 1) * PAGESIZE)

      14:         .Take(PAGESIZE)

      15:         .ToList()

      16:         .ForEach(n => Console.WriteLine(n));

      17: }

This will simply print 10 numbers (PAGESIZE) to the console depending on which page number you request.

1 2 3 4 5 6 7 8 9 10

However, one may have the requirement of displaying forward and backward navigation within your UI based on if there is more data to be paged to or not. This can easily be achieved by altering the above code snippet a bit.

       1: const int PAGESIZE = 10;

       2: static IEnumerable<int> numbers;

       3:  

       4: static void Main(string[] args)

       5: {

       6:     numbers = Enumerable.Range(1, 100);

       7:     PageNumbers(10);

       8:     Console.ReadLine();

       9: }

      10:  

      11: private static void PageNumbers(int pageNumber)

      12: {

      13:     var numbersPaged = numbers.Skip((pageNumber - 1) * PAGESIZE)

      14:         .Take(PAGESIZE + 1);

      15:  

      16:     if (numbersPaged.Count() > PAGESIZE)

      17:     {

      18:         Console.WriteLine("There are more pages.");

      19:         numbersPaged = numbersPaged.Take(PAGESIZE);

      20:     }

      21:  

      22:     numbersPaged

      23:         .ToList()

      24:         .ForEach(n => Console.Write("{0} ", n));

      25: }

When taking the next “PAGESIZE” number of rows, take one more additional row.

       14: .Take(PAGESIZE + 1);

Then, check if the numbers or rows in the subset of data is more than “PAGESIZE”. If so, you know that paging is required. Also remember to remove the last row from the subset of data before processing the data.

       19: numbersPaged = numbersPaged.Take(PAGESIZE);

SMTP service on Windows 7

2011-03-23T09:26:00.001-04:00

I recently installed Windows 7 on my notebook and so far am very impressed. However, as a developer that at times works in an offline mode, one of the features I miss is a local SMTP service. A SMTP service used to ship with IIS 6.0. However, IIS 7.0 does not ship a SMTP service.

After scouring around on the web and trying various SMTP service solutions, the one that I found to be pretty simple to install and configure is hMailServer. Just like the old SMTP that ships with IIS 6.0, hMailServer allows one to restrict access to the local machine (127.0.0.1) only in order to prevent being vulnerable to spam.

Some pointers on ensuring you restrict access to your local machine only.

Firstly, only allow SMTP protocol.

Next ensure that you restrict the IP address to the local host.

There are various other settings that can be tweaked, but out of the box with the above recommended settings should work well.

Update – 23 April 2011

As someone highlighted in the comments, there is an alternative SMTP solution at http://smtp4dev.codeplex.com/. This tool sits in the system tray and does not deliver the received messages. The received messages can be quickly viewed, saved and the source/structure inspected. Useful for testing/debugging software that generates email.

Technorati Tags: Windows 7,SMTP

MVC 3 partial model validation

2010-12-03T16:05:00.001-05:00

I recently wanted to partially validate a model in a controller action. There are various reasons why one would want to do this, just as there are reasons why one would not want to do this.

I have a view that only binds to a few of the properties within the model. Purists may claim that I should have a separate view that only contains the properties required for the view. I somewhat agree with this model, but there are times when the situation does not warrant all the work required to create yet another view model.

In my searches I eventually discovered 2 methods of doing this. One using an action filter attribute and the other validating the specific properties.

The action filter method removes all errors associated with properties that do not appear on the incoming values for the post. This method is described by Steve Sanderson here.

The other method validates specific properties and ignores properties with errors. This can be achieved using:

        1: ModelState.IsValidField(model, m => m.Email)

Notice that this is a strongly typed implementation. Compiler and intellisense is your friend. The native “IsValidField” accepts the property name as a string parameter:

       1: ModelState.IsValidField("Email")

What I hate about this is that the compiler cannot help you if you mistype the property name or even worse remove or rename the property. Actually, you do not get an exception at runtime. The code runs and returns true if you have the property name wrong.

In order to get the strongly typed implementation to work seamlessly, I have 2 other helper functions. Firstly an extension method on “ModelStateDictionary”.

         1: public static bool IsValidField<T, TProperty>(this ModelStateDictionary modelSate, T container, Expression<Func<T, TProperty>> property) where T : class

         2: {

         3:     return modelSate.IsValidField(property.GetPropertyName());

         4: }

And another extension method on “Expression<Func<T, TProperty>>”.

         1: public static string GetPropertyName<T, TProperty>(this Expression<Func<T, TProperty>> property) where T : class

         2: {

         3:     //get the property name

         4:     var memberExpression = property.Body as MemberExpression;

         5:     if (memberExpression == null) { throw new InvalidCastException(); }

         6:     return memberExpression.Member.Name;

         7: }

Remember to include the namespaces in order to see these extension methods appear within your code.

Windows Phone 7 Developer Launch

2010-10-04T23:53:00.001-04:00

October 12th will be the Windows Phone 7 Developer Launch. Click the image below for more details.

Enable IIS compression on RIA WCF Service

2010-08-25T15:16:00.001-04:00

Turns out that RIA by default uses a binary channel on its WCF service. So we already get some if the performance improvement as provided by binary. However, upon doing R&D I came across another “well known” feature of IIS that can help a lot – namely compression. IIS (both 6.5 and 7.0) provide native support for compression. It just needs to be configured correctly. These are the compression figures I got on some of our RIA functions:

Function	Before Compression	After Compression	Compressed
GetCountries	22,064	4,836	78%
GetCitizenshipCountries	14,174	3,159	78%
GetStateProvinces	373,608	75,532	80%
GetReasonsForLeaving	3,726	1,192	68%
GetSocialMediaType	364	270	26%

IIS will do HTTP compression until the CPU reaches 90%. Compression is then automatically switched off until the CPU reaches 50% at which time compression is enabled again. This is to ensure that the server CPU does not get overloaded with compression requests. IIS only does compression on requests that indicate the client is capable of supporting compression. This is usually indicated in the HTTP header.

To enable compression within IIS 7.0, the following needs to be done.

Ensure dynamic compression is enabled on the client.

http://www.iis.net/ConfigReference/system.webServer/httpCompression

Configure dynamic compression within IIS application host configuration file.

http://www.west-wind.com/Weblog/posts/447442.aspx

Editing the application host configuration file on server is explained in the URL above.

Ensure the “<httpCompression>” section looks somewhat as follows:

<httpCompression directory="%SystemDrive%\inetpub\temp\IIS Temporary Compressed Files">
<scheme name="gzip" dll="%Windir%\system32\inetsrv\gzip.dll" dynamicCompressionLevel="4" staticCompressionLevel="9" />
<scheme name="deflate" dll="C:\Windows\system32\inetsrv\gzip.dll" dynamicCompressionLevel="4" staticCompressionLevel="9" />
<staticTypes>
<add mimeType="text/*" enabled="true" />
<add mimeType="message/*" enabled="true" />
<add mimeType="application/x-javascript" enabled="true" />
<add mimeType="application/atom+xml" enabled="true" />
<add mimeType="application/xaml+xml" enabled="true" />
<add mimeType="*/*" enabled="false" />
</staticTypes>
<dynamicTypes>
<add mimeType="text/*" enabled="true" />
<add mimeType="message/*" enabled="true" />
<add mimeType="application/x-javascript" enabled="true" />
<add mimeType="application/msbin1" enabled="true" />
<add mimeType="*/*" enabled="false" />
</dynamicTypes>
</httpCompression>

Pay special attention to the “application/msbin1” settings (line 16) as this is the RIA service binary content type.

Configure compression within IIS.

http://www.iis.net/ConfigReference/system.webServer/httpCompression
Enabling static and dynamic compression is explained in the above URL.

Restart IIS.

Once all this is done, it’s a simple matter of running a network sniffer or developer tool to look at the http header being returned from IIS. The header will indicate that the content has been compressed.

A Word of Caution

Compression settings are tricky, and adding more compression will not necessarily increase the performance of your application. (Sometimes it will do the exact opposite!) Be sure to do your research first, and then test your new settings to make sure they’re having the effect you expected.

Of course this only applies to when you are hosting within IIS and not the VS development web server (Cassini).

Extending RIA generated entity classes client side.

2010-08-20T13:04:00.001-04:00

When using RIA services with your Silverlight (SL) application, RIA will generate (inject) matching entity class definitions within your SL application based on the types that gets used for method signatures. This code resides in a hidden files called “..\Generated_Code\<project name>.Web.g.cs”. The classes are all defined as partial and inherit from base class Entity.

        1: /// <summary>

       2: /// The 'Relationship' entity class.

       3: /// </summary>

       4: [DataContract(Namespace=http://schemas.datacontract.org/2004/07/xxxx)]

       5: public sealed partial class Relationship : Entity

       6: {

       7:     private Nullable<DateTime> _endDate;

       8:     private bool _hasEmploymentDocs;

       9:     private int _id;

      10:     ...

Entity base class implements interface “IEditableObject” and “INotifyPropertyChanged”. Implementing these 2 interfaces makes it possible to receive notification when a property changes, and for the object to be editable. This behavior becomes more obvious when using a “DataForm” control to edit the entity. When the “DataForm” enters edit mode, the entity automatically takes a snapshot of the entity’s state. Within edit mode, changes can be made to the entity. If however you decide not to commit the changes and click “Cancel”, the entity snapshot will be restored and the entity is back to it’s original state.

Because the class is defined as partial, this does enable one to “Extend” the entity class with additional properties in the client to support UI specific implementation details. The alternative is to include these properties on the server side definition of the class, but this will clutter the server side classes with UI specific properties, and there will be a performance overhead to serialize these properties over the wire. I prefer to stick to client side with these kinds of implementations. Extending a entity class is a simple matter of providing your own properties and hook into the property change notification implementation as supported by the entity.

       1: public sealed partial class Relationship

       2: {

       3:     private Unit selectedUnit;

       4:  

       5:     [Display(Name = "Entity")]

       6:     [Required(ErrorMessage = "An Entity is required.")]

       7:     public Unit SelectedUnit

       8:     {

       9:         get { return selectedUnit; }

      10:         set

      11:         {

      12:             if (selectedUnit != value)

      13:             {

      14:                 ValidateProperty("SelectedUnit", value);

      15:                 selectedUnit = value;

      16:                 RaisePropertyChanged("SelectedUnit");

      17:                 UnitId = value.Id;

      18:                 UnitName = value.Name;

      19:             }

      20:         }

      21:     }

      22:     ...

Depending on the type of the property, it may not be included in the “Snapshot” logic that is implemented by the entity. If not included, the property will never get restored to it’s original value when “Cancel” is clicked. The above example does not get included and one needs to implement a few extra pieces of logic before the “Cancel” operation will revert the above property back to it’s original state.

In the above scenario, the extended property “SelectedUnit” does rely on another property called “UnitId”. Since “UnitId” does not get bound to any UI, “SelectedUnit” does. There is a direct relationship between these 2 properties. We refer to “UnitId” as a “pass through” property.

For the “SelectedUnit” to be restored to it’s original state, we have to hook into the “UnitId” property changed notification and manually sync “SelectedUnit” to the “UnitId”.

A lot of this code is duplication when implementing this across multiple properties. When hooking into the entity property changed event, one needs to keep in mind that if not managed correctly, you could subscribe to the same event multiple times and thus get notified multiple times. The following helper class helps in managing the event subscription and removes a lot of the duplicate code one generally would have.

       1: /// <summary>

       2:     /// Write through property helper class.

       3:     /// </summary>

       4:     internal class WriteThroughPropertyHelper

       5:     {

       6:         private Dictionary<INotifyPropertyChanged, Dictionary<string, PropertyChangedEventHandler>> notifications = new Dictionary<INotifyPropertyChanged, Dictionary<string, PropertyChangedEventHandler>>();

       7:  

       8:         /// <summary>

       9:         /// Attaches the write through property.

        /// </summary>

        /// <typeparam name="T">Type of container.</typeparam>

        /// <typeparam name="TProperty">The type of the property</typeparam>

        /// <param name="container">The container.</param>

        /// <param name="property">The property.</param>

        /// <param name="filter">The filter.</param>

        /// <param name="action">The action.</param>

        public void AttachWriteThroughProperty<T, TProperty>(T container, Expression<Func<T, TProperty>> property, Func<T, TProperty, bool> filter, Action<T, TProperty> action) where T : class, INotifyPropertyChanged

        {

            if (container == null) { throw new ArgumentNullException("container"); }

            if (property == null) throw new ArgumentNullException("property");

            var propertyName = GetPropertyName<T, TProperty>(property);

  

            PropertyChangedEventHandler handler = (s, e) =>

            {

                var changedObject = s as T;

  

                if (changedObject != null)

                {

                    var result = property.Compile()(changedObject);

                    if (filter(changedObject, result)) { action(changedObject, result); }

                }

            };

  

            Dictionary<string, PropertyChangedEventHandler> notification;

  

            if (!notifications.TryGetValue(container, out notification))

            {

                notifications[container] = notification = new Dictionary<string, PropertyChangedEventHandler>();

                container.PropertyChanged += PropertyChangedHandler;

            }

  

            notification[propertyName] = handler;

        }

  

        /// <summary>

        /// Gets the name of the property.

        /// </summary>

        /// <typeparam name="T">Type of container.</typeparam>

        /// <typeparam name="TProperty">The type of the property.</typeparam>

        /// <param name="property">The property.</param>

        /// <returns>Property name.</returns>

        private static string GetPropertyName<T, TProperty>(Expression<Func<T, TProperty>> property) where T : class, INotifyPropertyChanged

        {

            //get the property name

            var memberExpression = property.Body as MemberExpression;

            if (memberExpression == null) { throw new InvalidCastException(); }

            return memberExpression.Member.Name;

        }

  

        /// <summary>

        /// Detaches the write through property.

        /// </summary>

        /// <param name="container">The container.</param>

        /// <param name="propertyName">Name of the property.</param>

        public void DetachWriteThroughProperty<T, TProperty>(T container, Expression<Func<T, TProperty>> property) where T : class, INotifyPropertyChanged

        {

            Dictionary<string, PropertyChangedEventHandler> notification;

  

            if (notifications.TryGetValue(container, out notification))

            {

                var propertyName = GetPropertyName<T, TProperty>(property);

                if (notification.ContainsKey(propertyName)) { notification.Remove(propertyName); }

                if (notification.Count == 0)

                {

                    container.PropertyChanged -= PropertyChangedHandler;

                    notifications.Remove(container);

                }

            }

        }

  

        /// <summary>

        /// Properties the changed handler.

        /// </summary>

        /// <param name="sender">The sender.</param>

        /// <param name="e">The <see cref="System.ComponentModel.PropertyChangedEventArgs"/> instance containing the event data.</param>

        private void PropertyChangedHandler(object sender, PropertyChangedEventArgs e)

        {

            var container = sender as INotifyPropertyChanged;

  

            if (container != null)

            {

                Dictionary<string, PropertyChangedEventHandler> notification;

  

                if (notifications.TryGetValue(container, out notification))

                {

                    PropertyChangedEventHandler handler;

                    if (notification.TryGetValue(e.PropertyName, out handler)) { handler(sender, e); }

                }

            }

        }

To associate the write through property with another property, it’s a matter of calling the “AttachWriteThroughProperty” function passing in the entity instance, property name that needs to be monitored for changes, a predicate that will determine whether the action must be executed or not and the action that must be executed if the predicate returns true.

       1: ...

       2: AttachWriteThroughProperty(value,

       3:     r => r.UnitId,

       4:     (r, id) => r.SelectedUnit.Id != id,

       5:     (r, id) => r.SelectedUnit = UnitsComboList.Where(u => u.Id == id).SingleOrDefault());

       6: ...

Find all parents or children for a dependency object in Silverlight

2010-07-30T08:49:00.001-04:00

Here are 2 helpful extension methods that can be used to find all parents or children for a dependency object within Silverlight.

Parents

        1: public static IEnumerable<DependencyObject> Parents(this DependencyObject root)

       2: {

       3:     var parent = VisualTreeHelper.GetParent(root);

       4:  

       5:     if (parent != null)

       6:     {

       7:         yield return parent;

       8:         foreach (var ascendent in Parents(parent))

       9:             yield return ascendent;

      10:     }

      11: }

Children

       1: public static IEnumerable<DependencyObject> Children(this DependencyObject root)

       2: {

       3:     int count = VisualTreeHelper.GetChildrenCount(root);

       4:  

       5:     for (int i = 0; i < count; i++)

       6:     {

       7:         var child = VisualTreeHelper.GetChild(root, i);

       8:         yield return child;

       9:         foreach (var descendent in Children(child))

      10:             yield return descendent;

      11:     }

      12: }

Usage pattern for getting all ProgressBar objects within the visual tree:

       1: this.Children().OfType<ProgressBar>().ToList().ForEach(p => p.IsIndeterminate = false);

Navigation in a MVVM Silverlight 3 application

2010-03-16T23:43:00.001-04:00

I’m currently working on a Silverlight 3 project that uses MVVM. We have been able to isolate most of the code within the view model. We are able to bind our commands to our view models using commanding as supplied by the MVVM Light toolkit. Another nice feature the toolkit provides is event aggregation (which is basically a message broadcast to subscribers).

One of the issues we have had some trouble with is navigation. Specifically navigation from the view model. Since the view model should not be aware of the view that is binding to it, the view model has no reference to a navigation service (which would have made things much easier). I tried various options to get navigation from a view model working in a satisfactory way.

Tried binding the navigation frame source property to the view model and then update the view model with the URL that I wanted to navigate to. Did not get this working.
Passed the navigation service reference to the view model. This worked, but did not follow the purist MVVM model since the view model has some “awareness” of the view.
Used event aggregation to publish the “Navigate” message. The main form that contains the navigation form subscribe to the “Navigate” message and would then navigate to the request URL. This worked the best for us.

The code for the main form:

        1: Public Sub New()

       2:     InitializeComponent()

       3:     Me.loginContainer.Child = New LoginStatus()

       4:  

       5:     'subscribe to navigation event (event aggregation)

       6:     Messenger.Default.Register(Me, GetType(NavigationMessage))

       7: End Sub

Notice in line 6 the form subscribes to the “Navigate” message.

The NavigationMessage definition:

       1: Public Class NavigationMessage

       2:     Inherits GenericMessage(Of Uri)

       3:     Public Sub New(ByVal sender As Object, ByVal content As Uri)

       4:         MyBase.New(sender, content)

       5:     End Sub

       6: End Class

The “Navigate” message content contains the URL to navigate to.

The view model code:

       1: ViewModelUtility.NavigateTo(Me, NavigationPage.PortfolioManager)

This will publish a “Navigate” message.

Lastly, the code in the main form to act on any message broadcasts:

       1: Public Sub ReceiveMessage(ByVal message As GalaSoft.MvvmLight.Messaging.MessageBase) Implements GalaSoft.MvvmLight.Messaging.IMessageRecipient.ReceiveMessage

       2:     Dim m_Message As NavigationMessage

       3:  

       4:     If TypeOf message Is NavigationMessage Then

       5:         m_Message = CType(message, NavigationMessage)

       6:  

       7:         If Not m_Message.Content Is Nothing Then

       8:             ContentFrame.Source = m_Message.Content

       9:         End If

      10:     End If

      11: End Sub

In line 8, the navigation frame source property is being set to the URL that was received within the “Navigate” message.

I hope that this gets read by the clever Silverlight MVVM folks out there and suggestions on how to improve or possibly a better way of doing this is provided.

Copy full file path to clipboard from Windows Explorer

2010-01-04T11:16:00.001-05:00

Update 1/4/2009: In the mean time, I discovered that on Windows 7 you can right click while holding down the shift key and this provides a menu option to copy file as path.

Till now, if I wanted to copy the full file path of a file to the clipboard, I would open the “run” window, drag the file from windows explorer to the “run” window, highlight the path in the “run” window and copy. It works but gets frustrating after having to do this several times.

I found this handy little utility that does this from the windows explorer context menu.

Technorati Tags: Windows 7 File Explorer Copy file path

VS 2008 Database Edition GDR R2 Deployment Scenario

2009-12-10T22:44:00.001-05:00

I have been using the GDR version for quite a few of my projects to date, and it has saved me so much time and work. It provides great source control of all database artifacts and makes it easy to do local database development in a distributed team environment. Once someone checks in their changes, I can do a get latest, compare my database project to my local schema and choose to apply the changes automatically or use the TSQL script that it produces to apply the updates.

Recently on a podcast, I heard that it was possible for GDR to upgrade a database from any state to the current state of your database project. This got me thinking, why do I go through all the effort to supply TSQL upgrade scripts from one version to the next at deploy time. Maybe I could use the capabilities that GDR provides to do all the grunt work for me. After scouring the internet for answers, I found this blog entry from Benjamin Day Consulting that provided all the required steps to do this. He also provides a handy utility that wraps up the complexity of VsDbCmd.

This is going to help in my future deployment scenarios.

Associating disk partitions with volumes that are not drive mounted.

2009-11-12T10:00:00.001-05:00

I am busy building a tool for a client and part of the requirement is to show all volumes associated with a disk. Generally this is easy since a disk is divided into one or more partitions and each partition has one volume which is drive mounted. The issue I ran into was when a folder mounted volume or un-mounted volume existed for the partition. WMI could not provide the association between the volume and the partition the volume was associated with (at least not from all the research I did on this).

When viewing a disk that has an un-mounted volume from disk manager, you will notice that the volume has no drives letters folder mount points assigned.

I found 2 ways that one could go about programmatically to associate the volume with a partition, and ultimately with a physical disk.

The one way uses disk extents and volume offsets. Read more about it on this blog entry.

The other way uses the QueryDosDevice API. It turns out that most (if not all) device have a target name and that the target name for both the partition and the volume are the same if the volume resides on that specific partition. Keep in mind that:

A volume can exists on one partition (simple volume).
A volume can exist on more than one partition (spanned volume).
A volume can have multiple mount points. One drive letter and multiple folder mount points.

The API declaration in c# is:

   1:          DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]

   2:          public static extern uint QueryDosDeviceW(string lpDeviceName, [Out] char[] lpTargetPath, uint ucchMax);

The wrapper function around this API is:

   1:  public static string QueryDosDevice(string device)

   2:          {

   3:              if (string.IsNullOrEmpty(device)) { throw new ArgumentNullException("device"); }

4:

   5:              uint _ReturnSize = 0;

   6:              int _MaxSize = 1024;

7:

   8:              while (_ReturnSize == 0)

   9:              {

  10:                  char[] _Buffer = new char[_MaxSize];

  11:                  _ReturnSize = NativeMethods.QueryDosDeviceW(device, _Buffer, (uint)_Buffer.Length);

  12:                  int _LastError = Marshal.GetLastWin32Error();

13:

  14:                  if (_ReturnSize > 0)

  15:                  {

  16:                      StringBuilder _Output = new StringBuilder((int)_ReturnSize);

17:

  18:                      for (int i = 0; i < _ReturnSize; i++)

  19:                      {

  20:                          if (_Buffer[i] != '\0')

  21:                          {

  22:                              _Output.Append(_Buffer[i]);

  23:                          }

  24:                      }

25:

  26:                      return _Output.ToString();

  27:                  }

  28:                  else if (_LastError == NativeMethods.ERROR_INSUFFICIENT_BUFFER)

  29:                  {

  30:                      _MaxSize *= 2;

  31:                  }

  32:                  else

  33:                  {

  34:                      throw new Win32Exception(_LastError);

  35:                  }

  36:              }

37:

  38:              return string.Empty;

  39:          }

To get the target name for a partition called “Disk #4, Partition #0”:

   1:  VirtualDiskUtility.QueryDosDevice("Harddisk4Partition1");

Notice that the partition number has been incremented by 1 when calling the API. This call returns a string of “\\Device\\HarddiskVolume7”.

To get the target name for a volume called “\\?\Volume{457accde-c7b0-11de-91bf-005056c00008}\”:

   1:  VirtualDiskUtility.QueryDosDevice(@"Volume{457accde-c7b0-11de-91bf-005056c00008}");

This call returns a string of “\\Device\\HarddiskVolume7”. And we have a match!

Copy full file path to clipboard from Windows Explorer

2009-09-18T11:21:00.001-04:00

I found this handy little utility that does this from the windows explorer context menu.

Technorati Tags: Windows 7 File Explorer Copy file path

SMTP service on Windows 7

2009-09-02T12:20:00.001-04:00

Some pointers on ensuring you restrict access to your local machine only.

Firstly, only allow SMTP protocol.

Next ensure that you restrict the IP address to the local host.

There are various other settings that can be tweaked, but out of the box with the above recommended settings should work well.

Technorati Tags: Windows 7,SMTP

Manipulate PDF documents from .Net

2009-04-24T09:50:00.001-04:00

If you ever want to manipulate PDF documents from within .Net, take a look at iTextSharp. It’s a managed .Net library ported from the familiar iText Java library. I provides very rich functionality including but not limited to:

Construct a PDF document from scratch.
Concatenate multiple PDF documents.
PDF stamping.
etc…

Reading and saving BLOB data in SQL Server

2009-04-24T09:43:00.001-04:00

Ever look for a quick way to read and store BLOB data in SQL Server. I needed something quick and did not want to write a quick c# console application that would do this for me. So, asking a few knowledgeable folks I know (thank you Mikey and Mark) and scouring the web, I came across the following to very helpful commands you can use.

To read BLOB data out of SQL Server and save it to a file on disk, use the BCP command as follows. Keep in mind that any paths specified are relative the the server running the SQL Server instance.

bcp "select idocument from devimagebase.dbo.tbl_documentimage WHERE ndocumentid = 9992561 " queryout "c:\Temp\TestOut.pdf" -T -n -Slocalhost

To upload BLOB data into SQL Server, use the OPENROWSET function.

Update tbl_documentimage

set idocument = (Select bulkcolumn from Openrowset( Bulk 'C:\temp\Sample.pdf', Single_Blob) as x)

where ndocumentid = 9992561

VSTS Unit Test “Type is not resolved” exception

2009-03-25T19:59:00.001-04:00

When running VS unit tests, VSTestHost is the process that initializes and runs the test. A new AppDomain gets created and the base directory for the AppDomain gets set to the unit test “Out” directory that contains all the assemblies and dependencies required to run the test. The test directory is called “TestResults” and is found in the same directory where the solution file resides. Within the “TestResults” directory you will find a bunch of sub-directories for every test run.

The exception above only appears in the rare circumstance that one may place data in the thread calling context to cater for a multitude of different scenarios. In our scenario, we are flowing contextual data across service and AppDomain boundaries. Once the unit test has completed, the executing thread returns to the default AppDomain for the VSTestHost process. Part of the process for returning to the default AppDomain is to de-serialize objects in it’s calling context. However, the BaseDirectory has already been reset back to the directory containing the VSTestHost executable which is “C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE”. This then cause the de-serialization to fail since the type being de-serialized cannot be found in the VSTestHost directory. The exception reads something along the lines of:

Unit Test Adapter threw exception: Type is not resolved for member 'xxx,xxx, Version=2.0.3370.22002, Culture=neutral, PublicKeyToken=null'

More detail can be found at:

http://social.msdn.microsoft.com/forums/en-US/vststest/thread/f6325a92-0231-45f3-92a5-176cc45691ad/

http://social.msdn.microsoft.com/forums/en-US/vststest/thread/81814766-a522-4a19-8575-7bc7f581623c/

This has been confirmed in various blogs and forums to be a bug. I am running VSTS 2008 SP1. As suggested in these entries, the hack that worked for us was to create a directory in “C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE” called “UnitTestAssemblies”. I copied all the required assemblies into this directory. I then manually edited the VSTestHost configuration file called “VSTestHost.exe.config” to include the directory I had created as part of it’s probing path:

   1: <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">

   2:     <probing privatePath="PrivateAssemblies;PublicAssemblies;UnitTestAssemblies"/>

   3: </assemblyBinding>

This will then force a lookup into the directory I created for any missing types during de-serialization. The folks at MS are apparently aware of this issue and hopefully will resole this soon. But for now, I guess this “hack” will work.

Linq-to-Xml vs. Regular Expression

2009-03-17T15:48:00.001-04:00

I came across some code that was using a regular expression to extract a value from a HTML page (another way to do screen scraping). I was curious what the performance difference between a regular expression and a Linq-to-Xml query would be.

I wanted to use a pretty sizable XML document, so I grabbed the MSDB db schema file for SQL Server 2008 that ships with VS Database Edition GDR. The file is about 1.8 MB. A snippet of the XML I wanted to query:

   1: <Element Type="ISql90File" Name="[MSDBLog]">

   2:     <Property Name="FileName" Value="$(DefaultDataPath)$(DatabaseName)Log.ldf" />

   3:     <Property Name="MaxSize" Value="2097152" />

   4:     <Property Name="FileGrowth" Value="10" />

   5:     <Property Name="FileGrowthUnit" Value="1" />

   6:     <Property Name="IsLogFile" Value="True" />

   7: </Element>

I wrote 2 functions to extract the value of the “Value” attribute for the “FileName” property element. In essence, the location of the MSDB log file.

The query using Linq-to-Sql:

   1: XElement _Root = XElement.Parse(xmlToSearch);

   2: return _Root.Descendants("Element").

   3:     Where(n => n.Attribute("Name") != null &&

   4:         n.Attribute("Name").Value == "[MSDBLog]" &&

   5:         n.Element("Property").Attribute("Name").Value == "FileName").

   6:     Select(n => n.Element("Property").Attribute("Value").Value).SingleOrDefault() ?? "not found";

The query using regular expression:

   1: Regex _Regex = new Regex("^.*?Name=\"\\[MSDBLog\\]\".*?Property Name=\"FileName\" Value=\"(?<Location>.*?)\".*$",

   2:     RegexOptions.IgnoreCase |

   3:     RegexOptions.Multiline |

   4:     RegexOptions.Singleline |

   5:     RegexOptions.CultureInvariant |

   6:     RegexOptions.Compiled);

   7: MatchCollection _Matches = _Regex.Matches(xmlToSearch);

   8: return ((from Match m in _Matches

   9:          where m.Groups["Location"] != null

  10:          select m.Groups["Location"].Value).SingleOrDefault()) ?? "not found";

One could argue that I am obscuring the results for the regular expression query because I am using Linq to extract the matched value from the matches found. The impact that the Linq query has on the overall result is minimal. Even with the Linq query commented out, the difference between the 2 queries remain comparably the same.

The results are as follows:

Linq-to-Xml outperforms the regular expression by about 24%.

Complete source code:

   1: static void Main(string[] args)

   2:         {

   3:             string _Xml = File.ReadAllText(@"C:\Program Files\Microsoft Visual Studio 9.0\VSTSDB\Extensions\SqlServer\2008\DBSchemas\msdb.dbschema");

   4:             Console.WriteLine("Read {0} characters\n", _Xml.Length);

5:

   6:             //search using linq-to-xml

   7:             TestFunction("Linq to Xml", _Xml, SearchLinqToXml);

8:

   9:             //search using regex

  10:             TestFunction("Regular Expression", _Xml, SearchRegex);

11:

  12:             //done

  13:             Console.WriteLine("\ndone...");

  14:             Console.ReadLine();

  15:         }

16:

  17:         private static void TestFunction(string name, string xmlToSearch, Func<string, string> searchFunction)

  18:         {

  19:             Stopwatch _Timer = new Stopwatch();

  20:             _Timer.Start();

  21:             Console.WriteLine("Result: {0}", searchFunction(xmlToSearch));

  22:             _Timer.Stop();

  23:             Console.WriteLine("{0} response: {1}", name, _Timer.ElapsedMilliseconds);

  24:         }

25:

  26:         private static string SearchRegex(string xmlToSearch)

  27:         {

  28:             Regex _Regex = new Regex("^.*?Name=\"\\[MSDBLog\\]\".*?Property Name=\"FileName\" Value=\"(?<Location>.*?)\".*$",

  29:                 RegexOptions.IgnoreCase |

  30:                 RegexOptions.Multiline |

  31:                 RegexOptions.Singleline |

  32:                 RegexOptions.CultureInvariant |

  33:                 RegexOptions.Compiled);

  34:             MatchCollection _Matches = _Regex.Matches(xmlToSearch);

  35:             return ((from Match m in _Matches

  36:                      where m.Groups["Location"] != null

  37:                      select m.Groups["Location"].Value).SingleOrDefault()) ?? "not found";

  38:         }

39:

  40:         private static string SearchLinqToXml(string xmlToSearch)

  41:         {

  42:             XElement _Root = XElement.Parse(xmlToSearch);

  43:             return _Root.Descendants("Element").

  44:                 Where(n => n.Attribute("Name") != null &&

  45:                     n.Attribute("Name").Value == "[MSDBLog]" &&

  46:                     n.Element("Property").Attribute("Name").Value == "FileName").

  47:                 Select(n => n.Element("Property").Attribute("Value").Value).SingleOrDefault() ?? "not found";

  48:         }

TFS GUI tool

2009-03-13T00:10:00.001-04:00

While reading Team Foundation Server 2008 in Action, I came across a tool that I found very helpful in providing a set of rich GUI based tools for TFS administrators and advanced users providing for administration and advanced version control tasks in multi-user TFS environments. Take a look at Team Foundation Sidekicks. It offers the following tools and also integrates in Visual Studio.

Permission Sidekick
Code Review Sidekick
Shelveset Sidekick
Labels Sidekick
History Sidekick
Status Sidekick
Workspace Sidekick

Variable access performance in a loop

2009-02-13T22:52:00.001-05:00

In an attempt to try and get code as optimized as possible, a friend (Brett) and I ran through various scenarios to see what the performance impact of each would be. We wanted to test accessing and incrementing a variable in a small loop. The results we got were as expected. However the difference between code compiled for debug and release was surprising.

We created the following scenarios accessing a variable within the loop:

Accessing a local variable.
Accessing a public member in a class.
Calling a function in the class to increment a local variable.
Accessing a property in a class.

The code we created may not make sense as production code. This was just to test the scenarios.

The class code:

   1: class MyClass

   2: {

   3:     public Int64 Cnt = 0;

4:

   5:     public Int64 Increment()

   6:     {

   7:         return ++Cnt;

   8:     }

9:

  10:     public Int64 Counter

  11:     {

  12:         get { return Cnt; }

  13:         set { Cnt = value; }

  14:     }

  15: }

The code using a local variable:

   1: Int64 n = 0;

2:

   3: while (n < 50000000)

   4: {

   5:     n++;

   6: }

The code using the public class member:

   1: MyClass _MyClass = new MyClass();

2:

   3: while (_MyClass.Cnt < 50000000)

   4: {

   5:     _MyClass.Cnt++;

   6: }

The code using a function:

   1: Int64 n = 0;

   2: MyClass _MyClass = new MyClass();

3:

   4: while (n < 50000000)

   5: {

   6:     n = _MyClass.Increment();

   7: }

Finally the code using a property:

   1: MyClass _MyClass = new MyClass();

2:

   3: while (_MyClass.Counter < 50000000)

   4: {

   5:     _MyClass.Counter++;

   6: }

Using the Stopwatch class provide by the framework we got the following results measured in milliseconds:

Running the exact same code in release mode produced the following results:

This is the part that surprised me. The big difference between debug and release mode. It’s not surprising that release code runs faster since there is no debug code injection. However, the difference in accessing the class property between debug and release is what caught my attention. There is obviously some serious code optimization in release mode for a property. Maybe some folks in the know of what optimization happens under the covers will respond to this post and share their knowledge with us.

Mark of the Web

2009-02-10T16:06:00.004-05:00

Working through a Silverlight 2.0 book and samples I came across an entry in the startup page that Visual Studio generates for you when compiling a Silverlight application.

   1: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

   2: <html xmlns="http://www.w3.org/1999/xhtml" >

   3: <!-- saved from url=(0014)about:internet -->

   4: <head>

Line 3 in the html sample above will tell IE (only certain versions of IE) that IE needs to run the page in the security zone specified – irrespective of where the page was loaded from. This is ideal if one quickly wants to test what a page's behavior will be in a different security zone. More information can be found on MSDN and the IE web blog.

Prevent Team Explorer from connecting to TFS at Visual Studio startup

2009-02-09T09:53:00.005-05:00

I got frustrated waiting for Visual Studio every time I start it up while it tried to connect to the last known TFS server. We have a VPN connection to our TFS server. The VPN is not always connected because I may be at a client or just quickly want to test some code without being connected. In an attempt to try and find a way to bypass the auto-connection behavior, I came across this posting by Merrick Chaffer.

Stopping Team Explorer from connecting on Visual Studio 2008 Start-up Add a DWORD value called "AutoLoadServer" under HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\9.0\TeamFoundation. Zero means do not reconnect automatically.

Very handy when you have multiple TFS servers or not always connected on the TFS server network.