.ToString(theory);

PLINQ–Not Just a Cool Sound

ToString(theory); — Sun, 10 Mar 2013 06:55:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2013/03/10/plinq-not-just-a-cool-sound.aspx

One of my favorite features in .Net 4 is the addition of the PLINQ extensions off the IEnumerable<T> for parallel queries of type ParallelQuery<T>. Even after talking to bunches of developers, it still seems to be one of the lesser known updates or packs of extension methods to .Net.

PLINQ allows for an easy way to dramatically increase the speed at which a query will run when the capability to run faster exists. Even though this great feature set exists, as always there are some gotchas to keep in mind before you start using it everywhere.

How to Use PLINQ

Thankfully, the PLINQ extension set is extremely simple to use. Have an IEnumerable<T>? Simply tack .AsParallel() after the collection, and your good to go:

var people = new List<People>();

//imagine code here that adds a whole lot of people to the List

//now, lets go Parallel people!

var parallelPeople = people.AsParallel();

That’s it! Now, parallelPeople will now dynamically scale to the most efficient number of threads/processes as guesstimated by some quick checks in .Net. In other words, run the query on a single core non-multithreaded, system, chances are this will run at its lowest efficiency. Up this to a 6 core multithreaded PC, and chances are you will end up with multiple threads executing your query – if it calls for it.

See, just because you have the multiple cores doesn’t always mean that it is most efficient to run a query across all of them. What if your list only has 1 or 2 objects in it? Is it really smart to try and scale that up to being processed by 6 separate threads, or even 2 threads? There is quite a bit of overhead in spinning up new threads and executing them, so PLINQ does some quick estimations and analyses on your query and collection to determine if it should even try to run it as a parallel task. Pretty neat right?!

Another thing to note is that after calling AsParallel(), you will notice that you actually have the ability to call almost every single LINQ extension still, but in parallel! Some may have different signatures that are more logical, such as renaming ForEach() off of a List instance, to a ForAll() for the ParallelQuery.

A Practical Example

Lets say that in your application, you need to do some operation on all of your Users in a system – maybe as part of a weekly batch operation for calculating statistics or something. So, the first thing you would want to do is to grab all of the users from your system… Assuming something like a Entity Framework context:

List<User> users = null;
using (YourAwesomeDbContext context = new YourAwesomeDbContext())
{
	users = context.Users.ToList();
}

You may have noticed, the first thing I did here was to declare a List<User> to hold my users from the database in, then I constructed the context and called ToList() on the Users DbSet. Why you may ask? The main reason is that the extension for AsParallel() is for an IEnumerable<T>… It expects that the collection that it is called on is an object collection, so if you run it on query that you are constructing on your context, you can end up with the unintentional side effect of pulling an entire set of data into memory, that you didn’t mean to. I’m not going to cover those details exactly here, but check out this post for a better overview of what I mean.

Now that you have the list of users, now you can perform some operations with them:

users.AsParallel().ForAll(u=> {
	//do some extensive operation for a user
});

And that is all it takes to perform an operation, in parallel, on a list!

Conclusion

The .Net PLINQ extensions can be a great addition to your every day toolset, however as the old adage goes – “With great power comes great responsibility”. My point is, don’t just go jump in and change ALL of your operations on lists and IEnumerable’s to PLINQ extensions. Look at the surrounding code. Are you sure that you are operating on an in-memory set already, or is the set still in the database/context? Should you really call AsParallel() at this point, or can you add a few filters first so you aren’t needlessly pulling down full collections, when you actually only need to iterate through 20%.

All in all though, PLINQ is a great thing to keep in mind when coding to jumpstart an operation/filtering/ordering to super proportions… I have actually coded items from using a ForEach() extension of of List, to an AsParallel().ForAll( { } ), and seen performance change from 60+ seconds, to around 3. YMMV.

Who could ask for more with LESS CSS? (Part 3 of 3–Clrizr)

ToString(theory); — Sun, 02 Dec 2012 11:36:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/12/02/who-could-ask-for-more-with-less-css-part-3.aspx

Welcome back! In the first two posts in this series, I covered some of the awesome features in CSS precompilers such as SASS and LESS, as well as how to get an initial project setup up and running in ASP.Net MVC 4. In this post, I will cover an actual advanced example of using LESS in a project, and show some of the great productivity features we gain from its usage.

Introduction

In the first post, I mentioned two subjects that I will be using in this example – constants, and color functions. I’ve always enjoyed using online color scheme utilities such as Adobe Kuler or Color Scheme Designer to come up with a scheme based off of one primary color. Using these tools, and requesting a complementary scheme you can get a couple of shades of your primary color, and a couple of shades of a complementary/accent color to display.

Because there is no way in regular css to do color operations or store variables, there was no way to accomplish something like defining a primary color, and have a site theme cascade off of that. However with tools such as LESS, that impossibility becomes a reality! So, if you haven’t guessed it by now, this post is on the creation of a plugin/module/less file to drop into your project, plugin one color, and have your primary theme cascade from it. I only went through the trouble of creating a module for getting Complementary colors. However, it wouldn’t be too much trouble to go through other options such as Triad or Monochromatic to get a module that you could use off of that.

Step 1 – Analysis

I decided to mimic Adobe Kuler’s Complementary theme algorithm as I liked its simplicity and aesthetics. Color Scheme Designer is great, but I do believe it can give you too many color options, which can lead to chaos and overload. The first thing I had to check was if the complementary values for the color schemes were actually hues rotated by 180 degrees at all times – they aren’t. Apparently Adobe applies some variance to the complementary colors to get colors that are actually more aesthetically appealing to users. So, I opened up Excel and began to plot complementary hues based on rotation in increments of 10:

Long story short, I completed the same calculations for Hue, Saturation, and Lightness. For Hue, I only had to record the Complementary hue values, however for saturation and lightness, I had to record the values for ALL of the shades.

Since the functions were too complicated to put into LESS since they aren’t constant/linear, but rather interval functions, I instead opted to extrapolate the HSL values using the trendline function for each major interval, onto intervals of spacing 1.

For example, using the hue extraction, I got the following values:

Interval	Function
0-60
60-140
140-270
270-360

Saturation and Lightness were much worse, but in the end, I finally had functions for all of the intervals, and then went the route of just grabbing each shades value in intervals of 1.

Step 2 – Mapping

I declared variable names for each of these sections as something that shouldn’t ever conflict with a variable someone would define in their own file. After I had each of the values, I extracted the values and put them into files of their own for hue variables, saturation variables, and lightness variables… Example:

/*HUE CONVERSIONS*/
@clrizr-hue-source-0deg: 133.43;
@clrizr-hue-source-1deg: 135.601;
@clrizr-hue-source-2deg: 137.772;
@clrizr-hue-source-3deg: 139.943;
@clrizr-hue-source-4deg: 142.114;
.../*SATURATION CONVERSIONS*/
@clrizr-saturation-s2SV0px: 0;
@clrizr-saturation-s2SV1px: 0;
@clrizr-saturation-s2SV2px: 0;
@clrizr-saturation-s2SV3px: 0;
@clrizr-saturation-s2SV4px: 0;
.../*LIGHTNESS CONVERSIONS*/
@clrizr-lightness-s2LV0px: 30;
@clrizr-lightness-s2LV1px: 31;
@clrizr-lightness-s2LV2px: 32;
@clrizr-lightness-s2LV3px: 33;
@clrizr-lightness-s2LV4px: 34;
...

In the end, I have 973 lines of mapping/conversion from source HSL to shade HSL for two extra primary shades, and two complementary shades. The last bit of the work was the file to compose each of the shades from these mappings.

Step 3 – Clrizr Mapper

The final step was the hardest to overcome as I was still trying to understand LESS to its fullest extent.

Imports

As mentioned previously, I had separated the HSL mappings into different files, so the first necessary step is to import those for use into the Clrizr plugin:

@import url("hue.less");
@import url("saturation.less");
@import url("lightness.less");

Extract Component Values For Each Shade

Next, I extracted the necessary information for each shade HSL before shade composition:

@clrizr-input-saturation: 1px+floor(saturation(@clrizr-input))-1;
@clrizr-input-lightness: 1px+floor(lightness(@clrizr-input))-1;
 
@clrizr-complementary-hue: formatstring("clrizr-hue-source-{0}", ceil(hue(@clrizr-input)));
 
@clrizr-primary-2-saturation: formatstring("clrizr-saturation-s2SV{0}",@clrizr-input-saturation);
@clrizr-primary-1-saturation: formatstring("clrizr-saturation-s1SV{0}",@clrizr-input-saturation);
@clrizr-complementary-1-saturation: formatstring("clrizr-saturation-c1SV{0}",@clrizr-input-saturation);
 
@clrizr-primary-2-lightness: formatstring("clrizr-lightness-s2LV{0}",@clrizr-input-lightness);
@clrizr-primary-1-lightness: formatstring("clrizr-lightness-s1LV{0}",@clrizr-input-lightness);
@clrizr-complementary-1-lightness: formatstring("clrizr-lightness-c1LV{0}",@clrizr-input-lightness);

Here, you can see a couple of odd things… On the first line, I am using operations to add units to the saturation and lightness. This is due to some limitations in the operations that would give me saturation or lightness in %, which can’t be in a variable name. So, I use first add 1px to it, which casts the result of the following functions as px instead of %, and then at the end, I remove that pixel.

You can also see here the formatstring method which is exactly what it sounds like – something like String.Format(string str, params object[] obj).

Get Primary & Complementary Shades

Now that I have components for each of the different shades, I can now compose them into each of their pieces. For this, I use the @@ operator which will look for a variable with the name specified in a string, and then call that variable:

@clrizr-primary-2: hsl(hue(@clrizr-input), @@clrizr-primary-2-saturation, @@clrizr-primary-2-lightness);
@clrizr-primary-1: hsl(hue(@clrizr-input), @@clrizr-primary-1-saturation, @@clrizr-primary-1-lightness);
@clrizr-primary: @clrizr-input;
@clrizr-complementary-1: hsl(@@clrizr-complementary-hue, @@clrizr-complementary-1-saturation, @@clrizr-complementary-1-lightness);
@clrizr-complementary-2: hsl(@@clrizr-complementary-hue, saturation(@clrizr-input), lightness(@clrizr-input));

That’s is it, for the most part. These variables now hold the theme for the one input color – @clrizr-input. However, I have one last addition…

Perceptive Luminance

Well, after I got the colors, I decided I wanted to also get the best font color that would go on top of it. Black or white depending on light or dark color. Now I couldn’t just go with checking the lightness, as that is half the story. You see, the human eye doesn’t see ALL colors equally well but rather has more cells for interpreting green light compared to blue or red. So, using the ratio, we can calculate the perceptive luminance of each of the shades, and get the font color that best matches it!

@clrizr-perceptive-luminance-ps2: round(1 - ( (0.299 *  red(@clrizr-primary-2)        )    + ( 0.587 * green(@clrizr-primary-2)        )    + (0.114 * blue(@clrizr-primary-2)))/255)*255;
@clrizr-perceptive-luminance-ps1: round(1 - ( (0.299 *  red(@clrizr-primary-1)        )    + ( 0.587 * green(@clrizr-primary-1)        )    + (0.114 * blue(@clrizr-primary-1)))/255)*255;
@clrizr-perceptive-luminance-ps:  round(1 - ( (0.299 *  red(@clrizr-primary)        )    + ( 0.587 * green(@clrizr-primary)        )    + (0.114 * blue(@clrizr-primary)))/255)*255;
@clrizr-perceptive-luminance-pc1: round(1 - ( (0.299 *  red(@clrizr-complementary-1))    + ( 0.587 * green(@clrizr-complementary-1))    + (0.114 * blue(@clrizr-complementary-1)))/255)*255;
@clrizr-perceptive-luminance-pc2: round(1 - ( (0.299 *  red(@clrizr-complementary-2))    + ( 0.587 * green(@clrizr-complementary-2))    + (0.114 * blue(@clrizr-complementary-2)))/255)*255;
 
@clrizr-col-font-on-primary-2: rgb(@clrizr-perceptive-luminance-ps2, @clrizr-perceptive-luminance-ps2, @clrizr-perceptive-luminance-ps2);
@clrizr-col-font-on-primary-1: rgb(@clrizr-perceptive-luminance-ps1, @clrizr-perceptive-luminance-ps1, @clrizr-perceptive-luminance-ps1);
@clrizr-col-font-on-primary: rgb(@clrizr-perceptive-luminance-ps, @clrizr-perceptive-luminance-ps, @clrizr-perceptive-luminance-ps);
@clrizr-col-font-on-complementary-1: rgb(@clrizr-perceptive-luminance-pc1, @clrizr-perceptive-luminance-pc1, @clrizr-perceptive-luminance-pc1);
@clrizr-col-font-on-complementary-2: rgb(@clrizr-perceptive-luminance-pc2, @clrizr-perceptive-luminance-pc2, @clrizr-perceptive-luminance-pc2);

Conclusion

That’s it! I have posted a project on clrizr.codePlex.com for this, and included a testing page for you to test out how it works. Feel free to use it in your own project, and if you have any questions, comments or suggestions, please feel free to leave them here as a comment, or on the contact page!

Who could ask for more with LESS CSS? (Part 2 of 3–Setup)

ToStringTheory — Fri, 30 Nov 2012 07:13:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/11/30/who-could-ask-for-more-with-less-css-part-2.aspx

Welcome to part two in my series covering the LESS CSS language. In the first post, I covered the two major CSS precompiled languages - LESS and SASS to a small extent, iterating over some of the features that you could expect to find in them. In this post, I will go a little further in depth into the setup and execution of using the LESS framework.

Introduction

It really doesn’t take too much to get LESS working in your project. The basic workflow will be including the necessary translator in your project, defining bundles for the LESS files, add the necessary code to your layouts.cshtml file, and finally add in all your necessary styles to the LESS files! Lets get started…

New Project

Just like all great experiments in Visual Studio, start up a File > New Project, and create a new MVC 4 Web Application.

The Base Package

After you have the new project spun up, use the Nuget Package Manager to install the Bundle Transformer: LESS package.

This will take care of installing the main translator that we will be using for LESS code (dotless which is another Nuget package), as well as the core framework for the Bundle Transformer library. The installation will come up with some instructions in a readme file on how to modify your web.config to handle all your *.less requests through the Bundle Transformer, which passes the translating onto dotless.

Where To Put These LESS Files?!

This step isn’t really a requirement, however I find that I don’t like how ASP.Net MVC just has a content directory where they store CSS, content images, css images…. In my project, I went ahead and created a new directory just for styles – LESS files, CSS files, and images that are only referenced in LESS or CSS.

Ignore the MVC directory as this was my testbed for another project I was working on at the same time. As you can see here, I have:

A top level directory for images which contains only images used in a page
A top level directory for scripts
A top level directory for Styles
1. A few directories for plugins I am using (Colrizr, JQueryUI, Farbtastic)
2. Multiple *.less files for different functions (I’ll go over these in a minute)

I find that this layout offers the best separation of content types.

Bring Out Your Bundles!

The next thing that we need to do is add in the necessary code for the bundling of these LESS files. Go ahead and open your BundleConfig.cs file, usually located in the /App_Start/ folder of the project. As you will see in a minute, instead of using the method Microsoft does in the base MVC 4 project, I change things up a bit.

Define Constants

The first thing I do is define constants for each of the virtual paths that will be used in the bundler:

The main reason is that I hate magic strings in my program, so the fact that you first defined a virtual path in the BundleConfig file, and then used that path in the _Layout.cshtml file really irked me.

Add Bundles to the BundleCollection

Next, I am going to define the bundles for my styles in my AddStyleBundles method:

That is all it takes to get all of my styles in play with LESS. The CssTransformer and NullOrderer types come from the Bundle Transformer we grabbed earlier. If we didn’t use that package, we would have to write our own function (not too hard, but why do it if it’s been done). I use the site.less file as my main hub for LESS - I will cover that more in the next section.

Add Bundles To Layout.cshtml File

With the constants in the BundleConfig file, instead of having to use the same magic string I defined for the bundle virtual path, I am able to do this:

Notice here that besides the RenderSection magic strings (something I am working on in another side project), all of the bundles are now based on const strings. If I need to change the virtual path, I only have to do it in one place. Nifty!

Get Started!

We are now ready to roll! As I said in the previous section, I use the site.less file as a central hub for my styles:

As seen here, I have a reset.css file which is a simple CSS reset. Next, I have created a file for managing all my color variables – colors.less:

Here, you can see some of the standards I started to use, in this case for color variables. I define all color variables with the @col prefix. Currently, I am going for verbose variable names.

The next file imported is my font.less file that defines the typeface information for the site:

Simple enough. A couple of imports for fonts from Google, and then declaring variables for use throughout LESS. I also set up the heading sizes, margins, etc.. You can also see my current standardization for font declaration strings – @font.

Next, I pull in a mixins.less file that I grabbed from the Twitter Bootstrap library that gives some useful parameterized mixins for use such as border-radius, gradient, box-shadow, etc…

The common.less file is a file that just contains items that I will be defining that can be used across all my LESS files. Kind of like my own mixins or font-helpers:

Finally I have my layout.less file that contains all of my definitions for general site layout – width, main/sidebar widths, footer layout, etc:

That’s it! For the rest of my one off definitions/corrections, I am currently putting them into the site.less file beneath my original imports

Note

Probably my favorite side effect of using the LESS handler/translator while bundling is that it also does a CSS checkup when rendering… See, when your web.config is set to debug, bundling will output the url to the direct less file, not the bundle, and the http handler intercepts the call, compiles the less, and returns the result. If there is an error in your LESS code, the CSS file can be returned empty, or may have the error output as a comment on the first couple lines.

If you have the web.config set to not debug, then if there is an error in your code, you will end up with the usual ASP.Net exception page (unless you catch the exception of course), with information regarding the failure of the conversion, such as brace mismatch, undefined variable, etc… I find it nifty.

Conclusion

This is really just the beginning. LESS is very powerful and exciting! My next post will show an actual working example of why LESS is so powerful with its functions and variables… At least I hope it will!

As for now, if you have any questions, comments, or suggestions on my current practice, I would love to hear them! Feel free to drop a comment or shoot me an email using the contact page. In the mean time, I plan on posting the final post in this series tomorrow or the day after, with my side project, as well as a whole base ASP.Net MVC4 templated project with LESS added in it so that you can check out the layout I have in this post.

Until next time…

Who could ask for more with LESS CSS? (Part 1 of 3–Features)

ToStringTheory — Mon, 26 Nov 2012 22:51:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/11/26/who-could-ask-for-more-with-less-css-part-1.aspx

It wasn’t very long ago that I first began to get into CSS precompilers such as SASS (Syntactically Awesome Stylesheets) and LESS (The Dynamic Stylesheet Language) and I had been hooked on the idea since. When I finally had a new project come up, I leapt at the opportunity to try out one of these languages.

Introduction

To be honest, I was hesitant at first to add either framework as I didn’t really know much more than what I had read on their homepages, and I didn’t like the idea of adding too much complexity to a project - I couldn’t guarantee I would be the only person to support it in the future.

Thankfully, both of these languages just add things into CSS. You don’t HAVE to know LESS or SASS to do anything, you can still do your old school CSS, and your output will be the same. However, when you want to start doing more advanced things such as variables, mixins, and color functions, the functionality is all there for you to utilize.

From what I had read, SASS has a few more features than LESS, which is why I initially tried to figure out how to incorporate it into a MVC 4 project. However, through my research, I couldn’t find a way to accomplish this without including some bit of the Ruby on Rails framework on the computer running it, and I hated the fact that I had to do that. Besides SASS, there is little chance of me getting into the RoR framework, at least in the next couple years. So in the end, I settled with using LESS.

Features

So, what can LESS (or SASS) do for you? There are several reasons I have come to love it in the past few weeks.

1 – Constants

Using LESS, you can finally declare a constant and use its value across an entire CSS file. The case that most people would be familiar with is colors. Wanting to declare one or two color variables that comprise the theme of the site, and not have to retype out their specific hex code each time, but rather a variable name. What’s great about this is that if you end up having to change it, you only have to change it in one place.

An important thing to note is that you aren’t limited to creating constants just for colors, but for strings and measurements as well.

2 – Inheritance

This is a cool feature in my mind for simplicity and organization. Both LESS and SASS allow you to place selectors within other selectors, and when it is compiled, the languages will break the rules out as necessary and keep the inheritance chain you created in the selectors.

Example LESS Code:

#header {
h1 {
    font-size: 26px;
    font-weight: bold;
}
p {
    font-size: 12px;
    a
    {
      text-decoration: none;
      &:hover {
        border-width: 1px
      }
    }
}
}

Example Compiled CSS:

#header h1
{
font-size: 26px;
font-weight: bold;
}
#header p
{
font-size: 12px;
}
#header p a
{
text-decoration: none;
}
#header p a:hover
{
border-width: 1px;
}

3 - Mixins

Mixins are where languages like this really shine. The ability to mixin other definitions setup a parametric mixin. There is really a lot of content in this area, so I would suggest looking at http://lesscss.org for more information. One of the things I would suggest if you do begin to use LESS is to also grab the mixins.less file from the Twitter Bootstrap project. This file already has a bunch of predefined mixins for things like border-radius with all of the browser specific prefixes. This alone is of great use!

4 – Color Functions

This is the last thing I wanted to point out as my final post in this series will be utilizing these functions in a more drawn out manner. Both LESS and SASS provide functions for getting information from a color (R,G,B,H,S,L). Using these, it is easy to define a primary color, and then darken or lighten it a little for your needs. Example:

Example LESS Code:

@base-color: #111;
@red: #842210;

#footer {
color: (@base-color + #003300);
border-left: 2px;
border-right: 2px;
border-color: desaturate(@red, 10%);
}

Example Compiled CSS:

#footer {
   color: #114411;
   border-left: 2px;
   border-right: 2px;
   border-color: #7d2717;
}

I have found that these can be very useful and powerful when constructing a site theme.

Conclusion

I came across LESS and SASS when looking for the best way to implement some type of CSS variables for colors, because I hated having to do a Find and Replace in all of the files using the colors, and in some instances, you couldn’t just find/replace because of the color choices interfering with other colors (color to replace of #000, yet come colors existed like #0002bc). So in many cases I would end up having to do a Find and manually check each one.

In my next post, I am going to cover how I’ve come to set up these items and the structure for the items in the project, as well as the conventions that I have come to start using. In the final post in the series, I will cover a neat little side project I built in LESS dealing with colors!

ANTS CLR and Memory Profiler In Depth Review (Part 2 of 2 – Memory Profiler)

ToStringTheory — Mon, 19 Nov 2012 09:39:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/11/19/ants-clr-and-memory-profiler-in-depth-review-part-2.aspx

One of the things that people might not know about me, is my obsession to make my code as efficient as possible. Many people might not realize how much of a task or undertaking that this might be, but it is surely a task as monumental as climbing Mount Everest, except this time it is a challenge for the mind… In trying to make code efficient, there are many different factors that play a part – size of project or solution, tiers, language used, experience and training of the programmer, technologies used, maintainability of the code – the list can go on for quite some time.

I spend quite a bit of time when developing trying to determine what is the best way to implement a feature to accomplish the efficiency that I look to achieve. One program that I have recently come to learn about – Red Gate ANTS Performance (CLR) and Memory profiler gives me tools to accomplish that job more efficiently as well. In this review, I am going to cover some of the features of the ANTS memory profiler set by compiling some hideous example code to test against.

Notice

As a member of the Geeks With Blogs Influencers program, one of the perks is the ability to review products, in exchange for a free license to the program. I have not let this affect my opinions of the product in any way, and Red Gate nor Geeks With Blogs has tried to influence my opinion regarding this product in any way.

Introduction – Part 2

In my last post, I reviewed the feature packed Red Gate ANTS Performance Profiler. Separate from the Red Gate Performance Profiler is the Red Gate ANTS Memory Profiler – a simple, easy to use utility for checking how your application is handling memory management… A tool that I wish I had had many times in the past. This post will be focusing on the ANTS Memory Profiler and its tool set.

The memory profiler has a large assortment of features just like the Performance Profiler, with the new session looking nearly exactly alike:

ANTS Memory Profiler

Memory profiling is not something that I have to do very often… In the past, the few cases I’ve had to find a memory leak in an application I have usually just had to trace the code of the operations being performed to look for oddities… Sadly, I have come across more undisposed/non-using’ed IDisposable objects, usually from ADO.Net than I would like to ever see. Support is not fun, however using ANTS Memory Profiler makes this task easier. For this round of testing, I am going to use the same code from my previous example, using the WPF application.

This time, I will choose the ‘Profile Memory’ option from the ANTS menu in Visual Studio, which launches the solution in its currently configured state/start-up project, and then launches the ANTS Memory Profiler to help. It prepopulates all of the fields with the current project information, and all I have to do is select the ‘Start Profiling’ option.

When the window comes up, it is actually quite barren, just giving ideas on how to work the profiler. You start by getting to the point in your application that you want to profile, and then taking a ‘Memory Snapshot’. This performs a full garbage collection, and snapshots the managed heap. Using the same WPF app as before, I will go ahead and take a snapshot now.

As you can see, ANTS is already giving me lots of information regarding the snapshot, however this is just a snapshot. The whole point of the profiler is to perform an action, usually one where a memory problem is being noticed, and then take another snapshot and perform a diff between them to see what has changed. I am going to go ahead and generate 5000 primes, and then take another snapshot:

As you can see, ANTS is already giving me a lot of new information about this snapshot compared to the last. Information such as difference in memory usage, fragmentation, class usage, etc… If you take more snapshots, you can use the dropdown at the top to set your actual comparison snapshots.

If you beneath the timeline, you will see a breadcrumb trail showing how best to approach profiling memory using ANTS. When you first do the comparison, you start on the Summary screen. You can either use the charts at the bottom, or switch to the class list screen to get to the next step. Here is the class list screen:

As you can see, it lists information about all of the instances between the snapshots, as well as at the bottom giving you a way to filter by telling ANTS what your problem is. I am going to go ahead and select the Int16[] to look at the Instance Categorizer

Using the instance categorizer, you can travel backwards to see where all of the instances are coming from. It may be hard to see in this image, but hopefully the lightbox (click on it) will help:

I can see that all of these instances are rooted to the application through the UI TextBlock control. This image will probably be even harder to see, however using the ‘Instance Retention Graph’, you can trace an objects memory inheritance up the chain to see its roots as well.

This is a simple example, as this is simply a known element. Usually you would be profiling an actual problem, and comparing those differences. I know in the past, I have spotted a problem where a new context was created per page load, and it was rooted into the application through an event. As the application began to grow, performance and reliability problems started to emerge. A tool like this would have been a great way to identify the problem quickly.

Overview

Overall, I think that the Red Gate ANTS Memory Profiler is a great utility for debugging those pesky leaks.

3 Biggest Pros:

Easy to use interface with lots of options for configuring profiling session
Intuitive and helpful interface for drilling down from summary, to instance, to root graphs
ANTS provides an API for controlling the profiler. Not many options, but still helpful.

2 Biggest Cons:

Inability to automatically snapshot the memory by interval
Lack of complete integration with Visual Studio via an extension panel

Ratings

Ease of Use (9/10) – I really do believe that they have brought simplicity to the once difficult task of memory profiling. I especially liked how it stepped you further into the drilldown by directing you towards the best options.

Effectiveness (10/10) – I believe that the profiler does EXACTLY what it purports to do.

Features (7/10) – A really great set of features all around in the application, however, I would like to see some ability for automatically triggering snapshots based on intervals or framework level items such as events.

Customer Service (10/10) – My entire experience with Red Gate personnel has been nothing but good. their people are friendly, helpful, and happy!

UI / UX (9/10) – The interface is very easy to get around, and all of the options are easy to find. With a little bit of poking around, you’ll be optimizing Hello World in no time flat!

Overall (9/10) – Overall, I am happy with the Memory Profiler and its features, as well as with the service I received when working with the Red Gate personnel.

Thank you for reading up to here, or skipping ahead – I told you it would be shorter! Please, if you do try the product, drop me a message and let me know what you think! I would love to hear any opinions you may have on the product.

Code

Feel free to download the code I used above – download via DropBox

SQL Azure Service Issues – 10.27.2012 (Restored Now)

ToStringTheory — Sun, 28 Oct 2012 04:26:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/10/27/sql-azure-service-issues-ndash-10.27.2012.aspx

Please note that if you have a Windows Azure website, or use SQL Azure, your site may be experiencing downtime currently.

Notice

I just called in regarding one of my public facing internet sites, because the site was failing to load anything but its error page, I couldn’t connect to the database to inspect application error logs, and the Windows Azure Management portal won’t load the SQL Azure extension.

After speaking to the representative, he also mentioned that they were also having some problems updating the Service Dashboard which shows service up/down time, and for now, they are posting messages at http://account.windowsazure.com. Please note that this issue may only be effecting certain regions.

Last, I may have misheard the representative, but he said that the outage was being categorized as a level 8, and if I heard correctly, I think he said that level 8 was the worst level. I can’t say for sure on this though, because the phone connection to their support number was bad – large amounts of white noise.

Good Luck!

Update

It appears that this outage may also be effecting the following services: SQL Database, Service Bus, Datamarket, Windows Azure Marketplace, Shared Caching, Access Control 2.0, and SQL Reporting. The note on the account page says for the South Central US region, however, I believe the representative I spoke to also mentioned North Central. As I said before though, the connection was bad.

Update 2

My site regained connectivity about an hour ago, and it appears that the service dashboard is back in operation with correct status and history. It does appear that I misheard on the phone regarding multiple regions, so chances are this only effected a percentage of the platform. All in all, if this WAS their worst level of a problem, they really got it fixed and back up pretty fast. All in all, I understand that it is inherent for a complex system such as Azure to have ups and downs, but at the end of the day, I am still happy to support Azure to its fullest!

ANTS CLR and Memory Profiler In Depth Review (Part 1 of 2 – CLR Profiler)

ToStringTheory — Mon, 22 Oct 2012 12:51:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/10/22/ants-clr-and-memory-profiler-in-depth-review-part-1.aspx

I spend quite a bit of time when developing trying to determine what is the best way to implement a feature to accomplish the efficiency that I look to achieve. One program that I have recently come to learn about – Red Gate ANTS Performance (CLR) and Memory profiler gives me tools to accomplish that job more efficiently as well. In this review, I am going to cover some of the features of the ANTS profiler set by compiling some hideous example code to test against.

Notice

Introduction

The ANTS Profiler pack provided by Red Gate was something that I had not heard of before receiving an email regarding an offer to review it for a license. Since I look to make my code efficient, it was a no brainer for me to try it out! One thing that I have to say took me by surprise is that upon downloading the program and installing it you fill out a form for your usual contact information. Sure enough within 2 hours, I received an email from a sales representative at Red Gate asking if she could help me to achieve the most out of my trial time so it wouldn’t go to waste.

After replying to her and explaining that I was looking to review its feature set, she put me in contact with someone that setup a demo session to give me a quick rundown of its features via an online meeting. After having dealt with a massive ordeal with one of my utility companies and their complete lack of customer service, Red Gates friendly and helpful representatives were a breath of fresh air, and something I was thankful for.

ANTS CLR Profiler

The ANTS CLR profiler is the thing I want to focus on the most in this post, so I am going to dive right in now. Install was simple and took no time at all. It installed both the profiler for the CLR and Memory, but also visual studio extensions to facilitate the usage of the profilers (click any images for full size images):

The Visual Studio menu options (under ANTS menu)

Starting the CLR Performance Profiler from the start menu yields this window

If you follow the instructions after launching the program from the start menu (Click File > New Profiling Session to start a new project), you are given a dialog with plenty of options for profiling:

The New Session dialog. Lots of options. One thing I noticed is that the buttons in the lower right were half-covered by the panel of the application. If I had to guess, I would imagine that this is caused by my DPI settings being set to 125%. This is a problem I have seen in other applications as well that don’t scale well to different dpi scales.

The profiler options give you the ability to profile:

.NET Executable
ASP.NET web application (hosted in IIS)
ASP.NET web application (hosted in IIS express)
ASP.NET web application (hosted in Cassini Web Development Server)
SharePoint web application (hosted in IIS)
Silverlight 4+ application
Windows Service
COM+ server
XBAP (local XAML browser application)
Attach to an already running .NET 4 process

Choosing each option provides a varying set of other variables/options that one can set including options such as application arguments, operating path, record I/O performance performance counters to record (43 counters in all!), etc… All in all, they give you the ability to profile many different .Net project types, and make it simple to do so. In most cases of my using this application, I would be using the built in Visual Studio extensions, as they automatically start a new profiling project in ANTS with the options setup, and start your program, however RedGate has made it easy enough to profile outside of Visual Studio as well.

On the flip side of this, as someone who lives most of their work life in Visual Studio, one thing I do wish is that instead of opening an entirely separate application/gui to perform profiling after launching, that instead they would provide a Visual Studio panel with the information, and integrate more of the profiling project information into Visual Studio.

So, now that we have an idea of what options that the profiler gives us, its time to test its abilities and features.

Horrendous Example Code – Prime Number Generator

One of my interests besides development, is Physics and Math – what I went to college for. I have especially always been interested in prime numbers, as they are something of a mystery… So, I decided that I would go ahead and to test the abilities of the profiler, I would write a small program, website, and library to generate prime numbers in the quantity that you ask for. I am going to start off with some terrible code, and show how I would see the profiler being used as a development tool.

First off, the IPrimes interface (all code is downloadable at the end of the post):

    interface IPrimes
    {
        IEnumerable<int> GetPrimes(int retrieve);
    }

Simple enough, right? Anything that implements the interface will (hopefully) provide an IEnumerable of int, with the quantity specified in the parameter argument. Next, I am going to implement this interface in the most basic way:

    public class DumbPrimes : IPrimes
    {
        public IEnumerable<int> GetPrimes(int retrieve)
        {
            //store a list of primes already found
            var _foundPrimes = new List<int>() { 2, 3 };

            //if i ask for 1 or two primes, return what asked for
            if (retrieve <= _foundPrimes.Count())
                return _foundPrimes.Take(retrieve);

            //the next number to look at
            int _analyzing = 4;

            //since I already determined I don't have enough
            //execute at least once, and until quantity is sufficed
            do
            {
                //assume prime until otherwise determined
                bool isPrime = true;
                
                //start dividing at 2
                //divide until number is reached, or determined not prime
                for (int i = 2; i < _analyzing && isPrime; i++)
                {
                    //if (i) goes into _analyzing without a remainder,
                    //_analyzing is NOT prime
                    if (_analyzing % i == 0)
                        isPrime = false;
                }
                
                //if it is prime, add to found list
                if (isPrime)
                    _foundPrimes.Add(_analyzing);
                
                //increment number to analyze next
                _analyzing++;
            } while (_foundPrimes.Count() < retrieve);

            return _foundPrimes;
        }
    }

This is the simplest way to get primes in my opinion. Checking each number by the straight definition of a prime – is it divisible by anything besides 1 and itself.

I have included this code in a base class library for my solution, as I am going to use it to demonstrate a couple of features of ANTS. This class library is consumed by a simple non-MVVM WPF application, and a simple MVC4 website. I will not post the WPF code here inline, as it is simply an ObservableCollection<int>, a label, two textbox’s, and a button.

Starting a new Profiling Session

So, in Visual Studio, I have just completed my first stint developing the GUI and DumbPrimes IPrimes class, so now I want to check my codes efficiency by profiling it. All I have to do is build the solution (surprised initiating a profiling session doesn’t do this, but I suppose I can understand it), and then click the ANTS menu, followed by Profile Performance. I am then greeted by the profiler starting up and already monitoring my program live:

You are provided with a realtime graph at the top, and a pane at the bottom giving you information on how to proceed. I am going to start by asking my program to show me the first 15000 primes:

After the program finally began responding again (I did all the work on the main UI thread – how bad!), I stopped the profiler, which did kill the process of my program too. One important thing to note, is that the profiler by default wants to give you a lot of detail about the operation – line hit counts, time per line, percent time per line, etc… The important thing to remember is that this itself takes a lot of time. When running my program without the profiler attached, it can generate the 15000 primes in 5.18 seconds, compared to 74.5 seconds – almost a 1500 percent increase. While this may seem like a lot, remember that there is a trade off. It may be WAY more inefficient, however, I am able to drill down and make improvements to specific problem areas, and then decrease execution time all around.

Analyzing the Profiling Session

After clicking ‘Stop Profiling’, the process running my application stopped, and the entire execution time was automatically selected by ANTS, and the results shown below:

Now there are a number of interesting things going on here, I am going to cover each in a section of its own:

Real Time Performance Counter Bar (top of screen)

At the top of the screen, is the real time performance bar. As your application is running, this will constantly update with the currently selected performance counters status. A couple of cool things to note are the fact that you can drag a selection around specific time periods to drill down the detail views in the lower 2 panels to information pertaining to only that period.

After selecting a time period, you can bookmark a section and name it, so that it is easy to find later, or after reloaded at a later time. You can also zoom in, out, or fit the graph to the space provided – useful for drilling down.

It may be hard to see, but at the top of the processor time graph below the time ticks, but above the red usage graph, there is a green bar. This bar shows at what times a method that is selected in the ‘Call tree’ panel is called. Very cool to be able to click on a method and see at what times it made an impact.

As I said before, ANTS provides 43 different performance counters you can hook into. Click the arrow next to the Performance tab at the top will allow you to change between different counters if you have them selected:

Method Call Tree, ADO.Net Database Calls, File IO – Detail Panel

Red Gate really hit the mark here I think. When you select a section of the run with the graph, the call tree populates to fill a hierarchical tree of method calls, with information regarding each of the methods.

By default, methods are hidden where the source is not provided (framework type code), however, Red Gate has integrated Reflector into ANTS, so even if you don’t have source for something, you can select a method and get the source if you want. Methods are also hidden where the impact is seen as insignificant – methods that are only executed for 1% of the time of the overall calling methods time; in other words, working on making them better is not where your efforts should be focused. – Smart!

Source Panel – Detail Panel

The source panel is where you can see line level information on your code, showing the code for the currently selected method from the Method Call Tree. If the code is not available, Reflector takes care of it and shows the code anyways!

As you can notice, there does seem to be a problem with how ANTS determines what line is the actual line that a call is completed on. I have suspicions that this may be due to some of the inline code optimizations that the CLR applies upon compilation of the assembly. In a method with comments, the problem is much more severe:

As you can see here, apparently the most offending code in my base library was a comment – *gasp*! Removing the comments does help quite a bit, however I hope that Red Gate works on their counter algorithm soon to improve the logic on positioning for statistics:

I did a small test just to demonstrate the lines are correct without comments.

For me, it isn’t a deal breaker, as I can usually determine the correct placements by looking at the application code in the region and determining what makes sense, but it is something that would probably build up some irritation with time.

Feature – Suggest Method for Optimization

A neat feature to really help those in need of a pointer, is the menu option under tools to automatically suggest methods to optimize/improve:

Nice feature – clicking it filters the call tree and stars methods that it thinks are good candidates for optimization. I do wish that they would have made it more visible for those of use who aren’t great on sight:

Process Integration

I do think that this could have a place in my process. After experimenting with the profiler, I do think it would be a great benefit to do some development, testing, and then after all the bugs are worked out, use the profiler to check on things to make sure nothing seems like it is hogging more than its fair share. For example, with this program, I would have developed it, ran it, tested it – it works, but slowly.

After looking at the profiler, and seeing the massive amount of time spent in 1 method, I might go ahead and try to re-implement IPrimes (I actually would probably rewrite the offending code, but so that I can distribute both sets of code easily, I’m just going to make another implementation of IPrimes). Using two pieces of knowledge about prime numbers can make this method MUCH more efficient – prime numbers fall into two buckets 6k+/-1 , and a number is prime if it is not divisible by any other primes before it:

    public class SmartPrimes : IPrimes
    {
        public IEnumerable<int> GetPrimes(int retrieve)
        {
            //store a list of primes already found
            var _foundPrimes = new List<int>() { 2, 3 };

            //if i ask for 1 or two primes, return what asked for
            if (retrieve <= _foundPrimes.Count())
                return _foundPrimes.Take(retrieve);

            //the next number to look at
            int _k = 1;

            //since I already determined I don't have enough
            //execute at least once, and until quantity is sufficed
            do
            {
                //assume prime until otherwise determined
                bool isPrime = true;
                int potentialPrime;
                
                //analyze 6k-1
                //assign the value to potential
                potentialPrime = 6 * _k - 1; 

                //if there are any primes that divise this, it is NOT a prime number
                //using PLINQ for quick boost
                isPrime = !_foundPrimes.AsParallel()
                                       .Any(prime => potentialPrime % prime == 0);

                //if it is prime, add to found list
                if (isPrime)
                    _foundPrimes.Add(potentialPrime);

                if (_foundPrimes.Count() == retrieve)
                    break;

                //analyze 6k+1
                //assign the value to potential
                potentialPrime = 6 * _k + 1;

                //if there are any primes that divise this, it is NOT a prime number
                //using PLINQ for quick boost
                isPrime = !_foundPrimes.AsParallel()
                                       .Any(prime => potentialPrime % prime == 0);

                //if it is prime, add to found list
                if (isPrime)
                    _foundPrimes.Add(potentialPrime);

                //increment k to analyze next
                _k++;
            } while (_foundPrimes.Count() < retrieve);

            return _foundPrimes;
        }
    }

Now there are definitely more things I can do to help make this more efficient, but for the scope of this example, I think this is fine (but still hideous)!

Profiling this now yields a happy surprise 27 seconds to generate the 15000 primes with the profiler attached, and only 1.43 seconds without. One important thing I wanted to call out though was the performance graph now:

Notice anything odd? The %Processor time is above 100%. This is because there is now more than 1 core in the operation. A better label for the chart in my mind would have been %Core time, but to each their own.

Another odd thing I noticed was that the profiler seemed to be spot on this time in my DumbPrimes class with line details in source, even with comments.. Odd.

Profiling Web Applications

The last thing that I wanted to cover, that means a lot to me as a web developer, is the great amount of work that Red Gate put into the profiler when profiling web applications. In my solution, I have a simple MVC4 application setup with 1 page, a single input form, that will output prime values as my WPF app did. Launching the profiler from Visual Studio as before, nothing is really different in the profiler window, however I did receive a UAC prompt for a Red Gate helper app to integrate with the web server without notification.

After requesting 500, 1000, 2000, and 5000 primes, and looking at the profiler session, things are slightly different from before:

As you can see, there are 4 spikes of activity in the processor time graph, but there is also something new in the call tree:

That’s right – ANTS will actually group method calls by get/post operations, so it is easier to find out what action/page is giving the largest problems… Pretty cool in my mind!

Overview

Overall, I think that Red Gate ANTS CLR Profiler has a lot to offer, however I think it also has a long ways to go.

3 Biggest Pros:

Ability to easily drill down from time graph, to method calls, to source code
Wide variety of counters to choose from when profiling your application
Excellent integration/grouping of methods being called from web applications by request – BRILLIANT!

3 Biggest Cons:

Issue regarding line details in source view
Nit pick – Processor time vs. Core time
Nit pick – Lack of full integration with Visual Studio

Ratings

Ease of Use (7/10) – I marked down here because of the problems with the line level details and the extra work that that entails, and the lack of better integration with Visual Studio.

Effectiveness (10/10) – I believe that the profiler does EXACTLY what it purports to do. Especially with its large variety of performance counters, a definite plus!

Features (9/10) – Besides the real time performance monitoring, and the drill downs that I’ve shown here, ANTS also has great integration with ADO.Net, with the ability to show database queries run by your application in the profiler. This, with the line level details, the web request grouping, reflector integration, and various options to customize your profiling session I think create a great set of features!

Customer Service (10/10) – My entire experience with Red Gate personnel has been nothing but good. their people are friendly, helpful, and happy!

UI / UX (8/10) – The interface is very easy to get around, and all of the options are easy to find. With a little bit of poking around, you’ll be optimizing Hello World in no time flat!

Overall (8/10) – Overall, I am happy with the Performance Profiler and its features, as well as with the service I received when working with the Red Gate personnel. I WOULD recommend you trying the application and seeing if it would fit into your process, BUT, remember there are still some kinks in it to hopefully be worked out.

My next post will definitely be shorter (hopefully), but thank you for reading up to here, or skipping ahead! Please, if you do try the product, drop me a message and let me know what you think! I would love to hear any opinions you may have on the product.

Code

Feel free to download the code I used above – download via DropBox

Blind As a Bat in Multi-Monitor Hell – Free Program Inside!

ToStringTheory — Sun, 16 Sep 2012 22:44:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/09/16/blind-as-a-bat-in-multi-monitor-hell-ndash-free-program.aspx

If you know me personally, then you probably know that I am going blind thanks to a rare genetic eye disease. My eye disease has already been a huge detriment to my eyesight. One of the big things to suffer is my ability to see small things moving fast right in front of me. On a multi-monitor setup, this makes finding the cursor absolute hell.

The Problem

I’ll keep this short, as I’ve basically already told you what the problem is. On my three monitor development computer, I am constantly losing the mouse during the day. I had used the Microsoft accessibility mousefinder (press CTRL, and it pings around the mouse). The problem with this is, there is only an effect around 50-100 PX around the mouse, and it is a very light gray, almost unnoticeable.. For someone like me, if I am not looking at the monitor when I click the CTRL button, I have to click it multiple times and dart my eyes back and forth in a futile attempt to catch a glimpse of the action… I had tried other cursor finders, but none I liked…

The Solution

So what’s a guy to do when he doesn’t like his options? MAKE A NEW OPTION… What else should we as developers do, am I right? So, I went ahead and made a mousefinder of my own, with 6 separate settings to change the effect. I am releasing it here for anyone else that may also have problems finding their mouse at times.

Some of its features include:

Multiple options to change to achieve the exact effect you want.
If your mouse moves while it is honing in, it will hone in on its current position.
Many times, I would press the button and move my mouse at the same time, and many times, the mouse happened to be at a screen edge, so I would miss it. This program will restart its animation on a new screen if the mouse changes its screen while playing.
Tested on Windows 7 x64
Stylish color changing from green to red.
Deployed as a ClickOnce, so easy to remove if you don't like it.
Press Right CTRL to trigger effect
Application lives in notification area so that you can easily reach configuration or close it.
To get it to run on startup, copy its application shortcut from its startmenu directory to the “Startup” folder in your startmenu.

Conclusion

I understand if you don’t download this… You don’t know me and I don’t know you. I can only say that I have honestly NOT added any virus’ or malware to the package.

Yeah, I know it’s weird	Download: ‘ToString(theory) Mousefinder.zip’
	CRC32: EEBCE300
	MD5: 0394DA581BE6F3371B5BA11A8B24BC91
	SHA-1: 2080C4930A2E7D98B81787BB5E19BB24E118991C

Finally, if you do use this application - please leave a comment, or email me and tell me what you think of it. Encounter a bug or hashes no longer match? I want to know that too!

<warning type=”BadPun”>Now, stop messing around and start mousing around!</warning>

Deploying an SSL Application to Windows Azure – The Dark Secret

ToStringTheory — Mon, 27 Aug 2012 00:28:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/08/26/deploying-an-ssl-application-to-windows-azure-ndash-the-dark.aspx

When working on an application that had been in production for some time, but was about to have a shopping cart added to it, the necessity for SSL certificates came up. When ordering the certificates through the vendor, the certificate signing request (CSR) was generated through the providers (http://register.com) web interface, and within a day, we had our certificate.

At first, I thought that the certification process would be the hard part… Little did I know that my fun was just beginning…

The Problem

I’ll be honest, I had never really secured a site before with SSL. This was a learning experience for me in the first place, but little did I know that I would be learning more than the simple procedure. I understood a bit about SSL already, the mechanisms in how it works – the secure handshake, CA’s, chains, etc… What I didn’t realize was the importance of the CSR in the whole process.

Apparently, when the CSR is created, a public key is created at the same time, as well as a private key that is stored locally on the PC that generated the request. When the certificate comes back and you import it back into IIS (assuming you used IIS to generate the CSR), all of the information is combined together and the SSL certificate is added into your store.

Since at the time the certificate had been ordered for our site, the selection to use the online interface to generate the CSR was chosen, the certificate came back to us in 5 separate files:

A root certificate – (*.crt file)
An intermediate certifcate – (*.crt file)
Another intermediate certificate – (*.crt file)
The SSL certificate for our site – (*.crt file)
The private key for our certificate – (*.key file)

Well, in case you don’t know much about Windows Azure and SSL certificates, the first thing you should learn is that certificates can only be uploaded to Azure if they are in a PFX package – securable by a password. Also, in the case of our SSL certificate, you need to include the Private Key with the file. As you can see, we didn’t have a PFX file to upload.

If you don’t get the simple PFX from your hosting provider, but rather the multiple files, you will soon find out that the process has turned from something that should be simple – to one that borders on a circle of hell… Probably between the fifth and seventh somewhere…

The Solution

The solution is to take the files that make up the certificates chain and key, and combine them into a file that can be imported into your local computers store, as well as uploaded to Windows Azure. I can not take the credit for this information, as I simply researched a while before finding out how to do this.

Download the OpenSSL for Windows toolkit (Win32 OpenSSL v1.0.1c)
Install the OpenSSL for Windows toolkit
Download and move all of your certificate files to an easily accessible location (you'll be pointing to them in the command prompt, so I put them in a subdirectory of the OpenSSL installation)
Open a command prompt
Navigate to the folder where you installed OpenSSL
Run the following command:

From this command, you will get a file, outcert.pfx, with the sum total of your ssl certificate (sslcert.crt), private key {keyfile.key}, and as many CA/chain files as you need {ca1.crt, ca2.crt}.

Taking this file, you can then import it into your own IIS in one operation, instead of importing each certificate individually. You can also upload the PFX to Azure, and once you add the SSL certificate links to the cloud project in Visual Studio, your good to go!

Conclusion

When I first looked around for a solution to this problem, there were not many places online that had the information that I was looking for. While what I ended up having to do may seem obvious, it isn’t for everyone, and I hope that this can at least help one developer out there solve the problem without hours of work!

SQL Saturday #150–Louisiana Region

ToStringTheory — Thu, 12 Jul 2012 22:13:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/07/12/sql-saturday-150ndashlouisiana-region.aspx

If you are in the region of Baton Rouge, LA on August 4th and are looking for some great fun, be sure to stop by SQL Saturday #150. We had more than 400 people attend last years event, and this it will be even BIGGER!

Information

This year we have a total of 11 tracks across a variety of different topics:

SQL DBA - 2 Tracks
SQL BI - 2 Tracks
SQL Dev - 1 Track
.Net Developer - 2 Tracks
IT Pro - 1 Track
Sharepoint - 1 Track
Career - 1 Track
Windows Phone 7 - 1 Track

We are very excited about all of the different choices, and especially our unique career track! With hints and tips on how to Ace that interview to a talk on Toastmasters, you're sure to find something that not only applies to you, but makes a difference!

Location

This year, SQL Saturday will be taking place at LSU's new Business Education complex - E. J. Ourso College of Business:

View Larger Map Get Directions View Bird's Eye

Conclusion

The event looks to be big and exciting, with lots of useful information. So remember, if you're in the area, you will want to stop by. Find out more information at the SQL Saturday #150 Event Information Homepage! There, you can find schedules and sponsor information, as well as register your attendance.

Recursion in the form of a Recursive Func<T, T>

ToStringTheory — Fri, 22 Jun 2012 01:23:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/06/21/recursion-in-the-form-of-a-recursive-funcltt-tgt.aspx

I gotta admit, I am kind of surprised that I didn’t realize I could do this sooner. I recently had a problem which required a recursive function call to come up with the answer. After some time messing around with a recursive method, and creating an API that I was not happy with, I was able to create an API that I enjoy, and seems intuitive.

Introduction

To bring it to a simple example, consider the summation to n:

A mathematically identical formula is:

In a .NET function, this can be represented by a function:

Func<int, int> summation = x => x*(x+1)/2

Calling summation with an input integer will yield the summation to that number:

var sum10 = summation(4);
//sum10 would be equal to 10

But what if I wanted to get a second level summation… First sum to n, and then use that argument as the input to the same function, to find the second level summation:

So as an easy example, calculate the summation to 3, which yields 6. Then calculate the summation to 6 which yields 21.

Represented as a mathematical formula -

So what if I wanted to represent this as .NET functions? I can always do:

//using the summation formula from above
var sum3 = summation(3); //sets sum3 to 6
var sum3_2 = summation(sum3); //sets sum3 to 21

I could always create a while loop to perform the calculations too:

Func<int, int> summation = x => x*(x+1)/2;

//for the interests of a smaller example, using shorthand

int sumResultTo = 3;

int level = 2;

while(level-- > 0)
    sumResultTo = summation(sumResultTo);

//sumResultTo is equal to 21 now.

Or express it as a for-loop, method calls, etc… I really didn’t like any of the options that I tried. Then it dawned on me – since I was using a Func<T, T> anyways, why not use the Func’s output from one call as the input to another directly.

Some Code

So, I decided that I wanted a recursion class. Something that would be generic and reusable in case I ever wanted to do something like this again. It is limited to only the Func<T1, T2> overload of Func, and T1 must be the same as T2.

The first thing in this class is a private field for the function:

private readonly Func<T, T> _functionToRecurse;

So, since I want the function to be unchangeable, I have defined it as readonly. Therefore my constructor looks like:

public Recursion(Func<T, T> functionToRecurse)
{
    if (functionToRecurse == null)
    {
        throw new ArgumentNullException("functionToRecurse", "The function to recurse can not be null");
    }
    _functionToRecurse = functionToRecurse;
}

Simple enough. Next, I want to be able to get the result of a function dependent on how many levels of recursion:

private Func<T, T> GetXLevel(int level)
{
    if (level < 1)
        throw new ArgumentOutOfRangeException("level", level, "The level of recursion must be greater than 0");

    if (level == 1)
        return _functionToRecurse;
    return _GetXLevel(level - 1, _functionToRecurse);
}

So, if you pass in 1 for the level, you get just the Func<T,T> back. If you say that you want to go deeper down the rabbit hole, it calls a method which accepts the level it is at, and the function which it needs to use to recurse further:

private Func<T, T> _GetXLevel(int level, Func<T, T> prevFunc)
{
    if (level == 1)
        return y => prevFunc(_functionToRecurse(y));
    return _GetXLevel(level - 1, y => prevFunc(_functionToRecurse(y)));
}

That is really all that is needed for this class. If I exposed the GetXLevel function publicly, I could use that to get the function for a level, and pass in the argument.. But I wanted something cleaner. So, I used the ‘this’ array operator for the class:

public Func<T,T> this[int level]
{
    get
    {
        if (level < 1)
        {
            throw new ArgumentOutOfRangeException("level", level, "The level of recursion must be greater than 0");
        }
        return this.GetXLevel(level);
    }
}

So, using the same example above of finding the second recursion of the summation of 3:

var summator = new Recursion<int>(x => (x * (x + 1)) / 2);
var sum_3_level2 = summator[2](3); //yields 21

You can even just store the delegate to the second level summation, and use it multiple times:

var summator = new Recursion<int>(x => (x * (x + 1)) / 2);
var sum_level2 = summator[2];
var sum_3_level2 = sum_level2(3); //yields 21
var sum_4_level2 = sum_level2(4); //yields 55
var sum_5_level2 = sum_level2(5); //yields 120

Full Code

Don’t think I was just going to hold off on the full file together and make you do the hard work… Copy this into a new class file:

public class Recursion<T>
{
    private readonly Func<T, T> _functionToRecurse;

    public Recursion(Func<T, T> functionToRecurse)
    {
        if (functionToRecurse == null)
        {
            throw new ArgumentNullException("functionToRecurse", "The function to recurse can not be null");
        }
        _functionToRecurse = functionToRecurse;
    }
    
    public Func<T,T> this[int level]
    {
        get
        {
            if (level < 1)
            {
                throw new ArgumentOutOfRangeException("level", level, "The level of recursion must be greater than 0");
            }
            return this.GetXLevel(level);
        }
    }
    
    private Func<T, T> GetXLevel(int level)
    {
        if (level < 1)
        {
            throw new ArgumentOutOfRangeException("level", level, "The level of recursion must be greater than 0");
        }
        if (level == 1)
            return _functionToRecurse;
        return _GetXLevel(level - 1, _functionToRecurse);
    }

    private Func<T, T> _GetXLevel(int level, Func<T, T> prevFunc)
    {
        if (level == 1)
            return y => prevFunc(_functionToRecurse(y));
        return _GetXLevel(level - 1, y => prevFunc(_functionToRecurse(y)));
    }
}

Conclusion

The great thing about this class, is that it can be used with any function with same input/output parameters. I strived to find an implementation that I found clean and useful, and I finally settled on this. If you have feedback – good or bad, I would love to hear it!

‘Publish…’ Resulting in Directory With No Files

ToStringTheory — Mon, 11 Jun 2012 07:20:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/06/11/lsquopublishhelliprsquo-resulting-in-directory-with-no-files.aspx

I was pulling my hair out with this one… Which isn’t good considering I have so little of it left! I had just upgraded to the Windows Azure 1.7 SDK the day before with no problems, and used the upgraded ‘Publish…’ dialog to successfully publish a website to my hard disk for hosting on an internal development server. However, when trying to deploy another project to my file system, it said it was successful, but there were no files in the directory. The only difference, the first project was an Azure project, the second was a standard ASP.Net Web Application. If you installed the Windows Azure 1.7 SDK, you may want to read this.

The Problem

At first it appears that there is no problem:

However you may remember that when publishing a web application, the output window will generally iterate through each of the directories as it copies the files from that directory over. Sure enough, when looking at the output directory – there are no files, no bin directory, no nothing…

Troubleshooting

Since one site published and the other did not, I believed that the failure may have been to a failed SQL Server 2012 installation that happened between publish. I rolled back the installation, however that did not work either.

I also checked the Configuration Manager dialog, and ensured that the projects were selected to actually build (just checking, even though the output said it built them..) I checked the properties of the solution and the projects, and a selection of files in the project to make sure that they were selected for content… Nothing seemed to work.

I then decided to uninstall the Azure 1.7 SDK to see if that was the culprit. When I opened the Windows 7 ‘Uninstall a Program’ dialog, I noticed that the Azure SDK came with 2 extra packages that just so happen to be in a Release Candidate state from Microsoft – ‘Microsoft Web Deploy 3.0’ and ‘Microsoft Web Publish – Visual Studio 2010’. It dawned on me that the publish dialog must not be just for Azure, since it appeared when I tried to deploy the regular web application as well. Therefore, it must have been an upgrade to the publish mechanism in Visual Studio. I uninstalled both of the programs and received my old publish dialog once again, and was able to successfully publish the solution above as I had done before.

After celebrating solving the problem, I tried reinstalling the Azure package, to see if it would repair the publishing process. Even though it brought back the updated dialogs, it did not publish any files. Instead of uninstalling and retreating, I now KNEW what the cause was, and these were packages not just for Azure. I now knew a product name to search for.

The Solution

Sure enough, with the correct search term in Google – ‘microsoft web publish no files’, and setting the timeline to 1 week, I found what I needed - Microsoft Connect - Publish Web Application FAILS! (by Andrew Rits).

I am surprised that I missed something that ended up being so simple… In the Configuration Manager, I had the following settings:

This is how I had been building and debugging the solution always… However, apparently when installing the new Web Publishing package, it does things a little differently in its configuration for publishing:

You see the difference? The configuration here is set to ‘x86’ instead of ‘Any CPU’. Sure enough, as soon as I switched the configuration to ‘Release – Any CPU’, the deployment built and published all of my files as I expected.

Conclusion

It was a small change, but apparently the new ‘Publish web application’ defaults to the x86 configuration, thereby not copying any of the project/bin files to the publish target directory. I spent forever trying things, but this small drop down eluded me until I was able to target that the dialog was actually working apparently, I just didn’t have the correct configuration.

I hope that this saves you the hours of frustration and hastened hair loss that it caused me… I also hope that before Microsoft brings this publishing package out of RC status, that they change the behavior of that menu to default to the settings of the old publish menu for the first time.

Happy Coding!

Windows Azure v1.7 Spring Release Today–New Management Dashboard

ToStringTheory — Fri, 08 Jun 2012 00:53:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/06/07/windows-azure-v1.7-spring-release-todayndashnew-management-dashboard.aspx

Today, Microsoft will be publicly releasing a new version of Azure for public consumption. The web conference, at http://www.meetwindowsazure.com will be airing at 1 PM PST. They have already released an update to the Service Dashboard that can be accessed by going to http://manage.windowsazure.com. I have some images of the new dashboard here that I have gathered and removed any PII from. Let me know what you think!

Images

You should be able to click any of the images for a full resolution image.

Tutorial

The first thing you get after signing in is the tutorial:

Landing

After the tutorial completes, you get a screen with services that are active on your account on the left, and a list of ALL services (db/blob/SQL Azure) on the right. I like the quick access to services across any of my subscriptions:

Service Information

These are images from a running web site with several roles. I love how easy they have made many of the features:

SQL Azure

They have given some great quick functionality for looking at your DB information:

Storage

Here is the basic information that they give you for any storage accounts you have:

Adding Services

Super quick and easy to add services with the new UI:

Conclusion

I am EXCITED! As you may have seen in the left side of my blog, I am an MCPD in Azure Development, and I must say that I am excited to see Microsoft moving forward with the technology and not letting it stagnate. After as much as I have fought the other Azure dashboard, I like the friendliness and fluidity of this one.

The important thing to note about ALL of the images above: this is HTML, not Silverlight. The responsiveness is FAST on all of the actions I completed, and I believe that this is a big step forward for Azure…

So, what do you think?

Visual Studio 2010 Productivity Tips and Tricks-Part 2: Key Shortcuts

ToStringTheory — Wed, 06 Jun 2012 07:52:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/06/06/visual-studio-2010-productivity-tips-and-tricks-part-2-key-shortcuts.aspx

Ask anyone that knows me, and they will confirm that I hate the mouse. This isn’t because I deny affection to objects that don’t look like their mammalian-named self, but rather for a much more simple and not-insane reason: I have terrible eyesight.

Introduction

Thanks to a degenerative eye disease known as Choroideremia, I have learned to rely more on the keyboard which I can feel digital/static positions of keys relative to my fingers, than the much more analog/random position of the mouse. Now, I would like to share some of the keyboard shortcuts with you now, as I believe that they not only increase my productivity, but yours as well once you know them (if you don’t already of course)... I share one of my biggest tips for productivity in the conclusion at the end.

Visual Studio Key Shortcuts

Global Editor Shortcuts

These are shortcuts that are available from almost any application running in Windows, however are many times forgotten.

Shortcut	Action	Visual Studio 2010 Functionality

Ctrl + X	Cut	This shortcut works without a selection. If nothing is selected, the entire line that the caret is on is cut from the editor.

Ctrl + C	Copy	This shortcut works without a selection. If nothing is selected, the entire line that the caret is on is copied from the editor.

Ctrl + V	Paste	If you copied an entire line by the method above, the data is pasted in the line above the current caret line.

Ctrl + Shift + V	Next Clipboard Element	Cut/Copy multiple things, and then hit this combo repeatedly to switch to the next clipboard item when pasting.

Ctrl + Backspace	Delete Previous	Will delete the previous word from the editor directly before the caret. If anything is selected, will just delete that.

Ctrl + Del	Delete Next Word	Will delete the next word/space from the editor directly after the caret. If anything is selected, will just delete that.

Shift + Del	Delete Focused Line	Will delete the line from the editor that the caret is on. If something is selected, will just delete that.

Ctrl + ← or Ctrl + →	Left/Right by Word	This will move the caret left or right by word or special character boundary. Holding Shift will also select the word.

Ctrl + F	Quick Find	Either the Quick Find panel, or the search bar if you have the Productivity Power Tools installed.

Ctrl + Shift + F	Find in Solution	Opens up the 'Find in Files' window, allowing you to search your solution, as well as using regex for pattern matching.

F2	Rename File...	While not debugging, selecting a file in the solution explorer\navigator and pressing F2 allows you to rename the selected file.

Global Application Shortcuts

These are shortcuts that are available from almost any application running in Windows, however are many times forgotten... Again...

Shortcut	Action	Visual Studio 2010 Functionality

Ctrl + N	New File dialog	Opens up the 'New File' dialog to add a new file to the current directory in the Solution\Project.

Ctrl + O	Open File dialog	Opens up the 'Open File' dialog to open a file in the editor, not necessarily in the solution.

Ctrl + S	Save File dialog	Saves the currently focused editor tab back to your HDD/SSD.

Ctrl + Shift + S	Save All...	Quickly save all open/edited documents back to your disk.

Ctrl + Tab	Switch Panel\Tab	Tapping this combo switches between tabs quickly. Holding down Ctrl when hitting tab will bring up a chooser window.

Building Shortcuts

These are shortcuts that are focused on building and running a solution. These are not usable when the IDE is in Debug mode, as the shortcut changes by context.

Shortcut	Action	Visual Studio 2010 Functionality

Ctrl + Shift + B	Build Solution	Starts a build process on the solution according to the current build configuration manager settings.

Ctrl + Break	Cancel a Building Solution	Will cancel a build operation currently in progress. Good for long running builds when you think of one last change.

F5	Start Debugging	Will build the solution if needed and launch debugging according to the current configuration manager settings.

Ctrl + F5	Start Without Debugger	Will build the solution if needed and launch the startup project without attaching a debugger.

Debugging Shortcuts

These are shortcuts that are used when debugging a solution.

Shortcut	Action	Visual Studio 2010 Functionality

F5	Continue Execution	Continues execution of code until the next breakpoint.

Ctrl + Alt + Break	Pause Execution	Pauses the program execution.

Shift + F5	Stop Debugging	Stops the current debugging session. NOTE: Web apps will still continue processing after stopping the debugger. Keep this in mind if working on code such as credit card processing.

Ctrl + Shift + F5	Restart Debugging	Stops the current debugging session and restarts the debugging session from the beginning.

F9	Place Breakpoint	Toggles/Places a breakpoint in the editor on the current line. Set a breakpoint in condensed code by highlighting the statement first.

F10	Step Over Statement	When debugging, executes all code in methods/properties on the current line until the next line.

F11	Step Into Statement	When debugging, steps into a method call so you can walk through the code executed there (if available).

Ctrl + Alt + I	Immediate Window	Open the Immediate Window to execute commands when execution is paused.

Navigation Shortcuts

These are shortcuts that are used for navigating in the IDE or editor panel.

Shortcut	Action	Visual Studio 2010 Functionality

Ctrl + -	Navigate Back	Use this combination to navigate through what you've viewed backwards

Ctrl + Shift + -	Navigate Forward	Use this combination to navigate through what you've viewed forwards (after having gone back).

F4	Properties Panel	Opens the properties panel for the selected item in the editor/designer/solution navigator (context driven).

F12	Go to Definition	Press F12 with the caret on a member to navigate to its declaration. With the Productivity tools, Ctrl + Click works too.

Ctrl + K Ctrl + T	View Call Hierarchy	View the call hierarchy of the member the caret is on. Great for going through n-tier solutions and interface implementations!

Ctrl + Alt + B	Breakpoint Window	View the breakpoint window to manage breakpoints and their advanced options. Allows easy toggling of breakpoints.

Ctrl + Alt + L	Solution Navigator	Open the solution explorer panel.

Ctrl + Alt + O	Output Window	View the output window to see build\general output from Visual Studio.

Ctrl + Alt + Enter	Live Web Preview	Only available with the Web Essential plugin. Launches the auto-updating Preview panel.

Testing Shortcuts

These are shortcuts that are used for running tests in the IDE. Please note, Visual Studio 2010 is all about context. If your caret is within a test method when you use one of these combinations, the combination will apply to that test. If your caret is within a test class, it will apply to that class. If the caret is outside of a test class, it will apply to all tests.

Shortcut	Action	Visual Studio 2010 Functionality

Ctrl + R T	Run Test(s)	Run all tests in the current context without a debugger attached. Breakpoints will not be stopped on.

Ctrl + R Ctrl + T	Run Test(s) (Debug)	Run all tests in the current context with a debugger attached. This allows you to use breakpoints.

Substitute A for T from the preceding combos to run/debug ALL tests in the current context.

Substitute Y for T from the preceding combos to run/debug ALL impacted/covering tests for a method in the current context.

Advanced Editor Shortcuts

These are shortcuts that are used for more advanced editing in the editor window.

Shortcut	Action	Visual Studio 2010 Functionality

Shift + Alt + ↑ Shift + Alt + ↓	Multiline caret up/down	Use this combo to edit multiple lines at once. Not too many uses for it, but once in a blue moon one comes along.

Ctrl + Alt + Enter	Insert Line Above	Inserts a blank line above the line the caret is currently on. No need to be at end or start of line, so no cutting off words/code.

Ctrl + K Ctrl + C	Comment Selection	Comments the current selection out of compilation.

Ctrl + K Ctrl + U	Uncomment Selection	Uncomments the current selection into compilation.

Ctrl + K Ctrl + D	Format Document	Automatically formats the document into a structured layout. Lines up nodes or code into columns intelligently.

Alt + ↑ Alt + ↓	Code line up/down	*Use this combo to move a line of code up or down quickly. Great for small rearrangements of code.

*Requires the Productivity Power pack from Microsoft.

Conclusion

This list is by no means meant to be exhaustive, but these are the shortcuts I use regularly every hour/minute of the day. There are still 100s more in Visual Studio that you can discover through the configuration window, or by tooltips.

Something that I started doing months ago seems to have interest in my office.. In my last post, I talked about how I hated a cluttered UI. One of the ways that I aimed to resolve that was by systematically cleaning up the toolbars week by week. First day, I removed ALL icons that I already knew shortcuts to, or would never use them (Undo in a toolbar?!). Then, every week from that point on, I make it a point to remove an icon/two from the toolbar and make an effort to remember its key combination. I gain extra space in the toolbar area, AND become more productive at the same time!

I hope that you found this article interesting or at least somewhat informative.. Maybe a shortcut or two you didn't know. I know some of them seem trivial, but I often see people going to the edit menu for Copy/Paste... Thought a refresher might be helpful!

Visual Studio 2010 Productivity Tips and Tricks–Part 1: Extensions

ToStringTheory — Wed, 30 May 2012 22:00:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/05/30/visual-studio-2010-productivity-tips-and-tricksndashpart-1-extensions.aspx

I don’t know about you, but when it comes to development, I prefer my environment to be as free of clutter as possible. It may surprise you to know that I have tried ReSharper, and did not like it, for the reason that I stated above. In my opinion, it had too much clutter. Don’t get me wrong, there were a couple of features that I did like about it (inversion of if blocks, code feedback), but for the most part, I actually felt that it was slowing me down.

Introduction

Another large factor besides intrusiveness/speed in my choice to dislike ReSharper would probably be that I have become comfortable with my current setup and extensions. I believe I have a good collection, and am quite happy with what I can accomplish in a short amount of time. I figured that I would share some of my tips/findings regarding Visual Studio productivity here, and see what you had to say.

The first section of things that I would like to cover, are Visual Studio Extensions. In case you have been living under a rock for the past several years, Extensions are available under the Tools menu in Visual Studio:

The extension manager enables integrated access to the Microsoft Visual Studio Gallery online with access to a few thousand different extensions. I have tried many extensions, but for reasons of lack reliability, usability, or features, have uninstalled almost all of them. However, I have come across several that I find I can not do without anymore:

Extensions

NuGet Package Manager

To be honest, I debated on whether or not to put this in here. Most people seem to have it, however, there was a time when I didn’t, and was always confused when blogs/posts would say to right click and “Add Package Reference…” which with one of the latest updates is now “Manage NuGet Packages”. So, if you haven’t downloaded the NuGet Package Manager yet, or don’t know what it is, I would highly suggest downloading it now!

Features

Simply put, the NuGet Package Manager gives you a GUI and command line to access different libraries that have been uploaded to NuGet. Some of its features include:

Ability to search NuGet for packages via the GUI, with information in the detail bar on the right.
Quick access to see what packages are in a solution, and what packages have updates available, with easy 1-click updating.
If you download a package that requires references to work on other NuGet packages, they will be downloaded and referenced automatically.

Productivity Tip

If you use any type of source control in Visual Studio as well as using NuGet packages, be sure to right-click on the solution and click "Enable NuGet Package Restore". What this does is add a NuGet package to the solution so that it will be checked in along side your solution, as well as automatically grab packages from NuGet on build if needed. This is an extremely simple system to use to manage your package references, instead of having to manually go into TFS and add the Packages folder.

Perspectives

I can't stand developing with just one monitor. Especially if it comes to debugging. The great thing about Visual Studio 2010, is that all of the panels and windows are floatable, and can dock to other screens. The only bad thing is, I don't use the same toolset with everything that I am doing. By this, I mean that I don't use all of the same windows for debugging a web application, as I do for coding a WPF application. Only thing is, Visual Studio doesn't save the screen positions for all of the undocked windows. So, I got curious one day and decided to check and see if there was an extension to help out. This is where I found Perspectives.

Features

Perspectives gives you the ability to configure window positions across any or your monitors, and then to save the positions in a profile.
Perspectives offers a Panel to manage different presets/favorites, and a toolbar to add to the toolbars at the top of Visual Studio.
Ability to 'Favorite' a profile to add it to the perspectives toolbar.

Productivity Tip

Take the time to setup profiles for each of your scenarios - debugging web/winforms/xaml, coding, maintenance, etc. Try to remember to use the profiles for a few days, and at the end of a week, you may find that your productivity was never better.

Productivity Power Tools

Ah, the Productivity Power Tools... Quite possibly one of my most used extensions, if not my most used. The tool pack gives you a variety of enhancements ranging from key shortcuts, interface tweaks, and completely new features to Visual Studio 2010.

Features

I don't want to bore you with all of the features here, so here are my favorite:

Quick Find - Unobtrusive search box in upper-right corner of the code window. Great for searching in general, especially in a file.
Solution Navigator - The 'Solution Explorer' on steroids. Easy to search for files, see defined members/properties/methods in files, and my favorite feature is the 'set as root' option.
Updated 'Add Reference...' Dialog - This is probably my favorite enhancement period... The 'Add Reference...' dialog redone in a manner that resembles the Extension/Package managers. I especially love the ability to search through all of the references.
"Ctrl - Click" for Definition - I am still getting used to this as I usually try to use my keyboard for everything, but I love the ability to hold Ctrl and turn property/methods/variables into hyperlinks, that you click on to see their definitions. Great for travelling down a rabbit hole in an application to research problems.

While there are other commands/utilities, I find these to be the ones that I lean on the most for the usefulness.

Web Essentials

If you have do any type of web development in ASP .Net, ASP .Net MVC, even HTML, I highly suggest grabbing the Web Essentials right NOW! This extension alone is great for productivity in web development, and greatly decreases my development time on new features.

Features

Some of its best features include:

CSS Previews - I say 'previews' because of the multiple kinds of previews in CSS that you get font-family, color, background/background-image previews. This is great for just tweaking UI slightly in different ways and seeing how they look in the CSS window at a glance.
Live Preview - One word - awesome! This goes well with my multi-monitor setup. I put the site on one monitor in a Live Preview panel, and then as I make changes to CSS/cshtml/aspx/html, the preview window will update with each save/build automatically. For CSS, you can even turn on live-update, so as you are tweaking CSS, the style changes in real time. Great for tweaking colors or font-sizes.
Outlining - Small, but I like to be able to collapse regions/declarations that are in the way of new work, or are just distracting.
Commenting Shortcuts - I don't know why it wasn't included by default, but it is nice to have the key shortcuts for commenting working in the CSS editor as well.

Productivity Tip

When working on a site, hit CTRL-ALT-ENTER to launch the Live Preview window. Dock it to another monitor. When you make changes to the document/css, just save and glance at the other monitor. No need to alt tab, then alt tab before continuing editing.

Conclusion

These extensions are only the most useful and least intrusive - ones that I use every day. The great thing about Visual Studio 2010 is the extensibility options that it gives developers to utilize. Have an extension that you use that isn't intrusive, but isn't listed here? Please, feel free to comment. I love trying new things, and am always looking for new additions to my toolset of the most useful.

Finally, please keep an eye out for Part 2 on key shortcuts in Visual Studio. Also, if you are visiting my site (http://tostringtheory.com || http://geekswithblogs.net/tostringtheory) from an actual browser and not a feed, please let me know what you think of the new styling!

ArgumentException with Windows Phone Mango SQLCE Decimal

ToStringTheory — Tue, 08 May 2012 17:08:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/05/08/argumentexception-with-windows-phone-mango-sqlce-decimal.aspx

Quick math question… If I asked you, “is 8 both greater than 0, and less than 38,” what would be your answer?? Well, if you answered yes, than you would be wrong… At least according to LINQ-to-SQL:

My reaction - “Uhhhhhhh.. WHAT?!?”

The Setup

I am running Visual Studio 2010 Premium SP1 with the Windows Phone 7.1 SDK. I used the instructions at WindowsPhoneGeek - Using SqlMetal to generate Windows Phone Mango Local Database classes to generate the code files for the database context in my application. The process was easy, and seemed to work flawlessly.

The Problem

Well, I doubt I need to explain much here… I reread the exception multiple times to make sure that I hadn’t had a random bout of temporary dyslexia hit, but no matter how many times I read this, I read the same thing. I checked all of the database context, and the attribute for the property that throws the exception, and everything appears to be fine.

This is the actual property that is throwing the exception – the only one that is a Decimal on the entire entity

The REALLY weird thing is, the exception isn’t thrown consistently. I can run the application 10 times in a row, with the same exact data flowing into it, performing the same network calls, but for some reason, about 2-3% of the time, I will get the exception listed above. On top of this, the other weird thing is that the application will have already run through the code several times for other objects without any exception. It doesn’t even always fail on the same objects, sometimes it is after processing 2-3 things, others on the 20 or 30th..

Hunting the Bug

I would like to be able to instead have information on a solution or fix, but I can’t provide that. I have tried over and over to produce a test case that will generate the error reliably, and I can’t do it. It only seems to happen when the application is running, and as I had said, it will work once, and then 1 minute later with the same information (application restarted), fail. The only thing that I can think of off the top of my head is that my application relies heavily on the ThreadPool for queuing actions, so that the interface isn’t sluggish. I even tried to do the same in my test cases (I am using TDD with a test harness), and still couldn’t produce the bug. So, I am left to this… I never wanted to post a blog where I didn’t have a solution, but now I have decided to try it to see if you the readers have the answer. If you do, I would be greatly appreciative of any hints or tips to find it, and will come back to edit this post with a solution… For now, this will serve as a placeholder for other lost souls that have tried searching the issue but found nothing – you are not alone… Now, let me go find some math books and brush up on basic math…

Enabling Google Webmaster Tools With Your GWB Blog

ToStringTheory — Mon, 09 Apr 2012 23:30:00 GMT

Originally posted on: http://geekswithblogs.net/ToStringTheory/archive/2012/04/09/enabling-google-webmaster-tools-with-your-gwb-blog.aspx

I’ll be honest and save you some time, if you don’t have your own domain for your GWB blog, this won’t help, you may just want to move on… I don’t want to waste your time………

Still here? Good. How great are Google’s website tools? I don’t just mean Analytics which rocks, but also their Webmaster Tools (https://www.google.com/webmasters/tools/) which gives you a glimpse into the queries that provide you your website traffic, search engine behavior on your site, and important keywords, just to name a few.

Pictured Above: Cool statistics.

Problem

Thanks to svickn over at wtfnext.com (another GeeksWithBlogs blog), we already have the knowledge on how to setup Google Analytics (wtfnext.com - How to: Set up Google Analytics on your GeeksWithBlogs blog). However, one of the questions raised in the post, and even semi-answered in the questions, was how to setup Google Webmaster Tools with your blog as well.

At first glance, it seems like it can’t be done. Google graciously gives you several different options on how to authorize that you own a site. The authentication options are:

1. (Recommended) – Upload an HTML file to your server

2. Add a meta tag to your site’s home page

3. Use your Google Analytics account

4. Add a DNS record to your domain’s configuration

Since you don’t have access to the base path, you can’t do #1. Same goes for #2 since you can’t edit the master/index page. As for #3, they REQUIRE the Analytics code to be in the <head> section of your page, so even though we can use the workaround of hosting it in the news section, it won’t allow it since it isn’t in the correct place.

Solution

Last I checked, I didn’t see the DNS record option for Webmaster Tools. Maybe this was recently added, or maybe I don’t remember it since I was always able to use some other method to authorize it. In this case though, this is the option that we need. My registrar wasn’t in their list, but they provide detailed enough instructions for the ‘Other’ option:

Simply create a TXT record with your domain hoster (mine is DynDns), fill in the tag information, and then click verify. My entry was able to be resolved immediately, but since you are working with DNS, it may take longer. If after 24 hours you still aren’t able to verify, you can use a site such as mxtoolbox.com, and in the searchbox type “txt: {domain-name-here}”, to see if your TXT record was entered successfully.

It is pretty simple to setup the TXT entry in DynDns, but if you have questions/comments, feel free to post them.

Conclusion

With this simple workaround (not really a workaround, but feature since they offer it..), you are now able to see loads of information regarding your standings in the world of the Google Search Engine.

No critical issues? Did I do something wrong?!

As an aside, you can do the same thing with the Bing Webmaster Tools by adding a CNAME record to bing.verify.com… Instructions can be found on the ‘Add Site’ popup when adding your site.

If you don’t have your own domain, but continued, to read to this point – thank you!