Codemares

Remote Desktop to Ubuntu in Azure

noreply@blogger.com (Anonymous) — Mon, 05 Nov 2012 15:19:00 +0000

After having seen a question on the "Connect" site about this, I decided to write a quick blog post on how to set up Remote Desktop (RDP) in Azure for a Linux installation (Ubuntu in this case).

After I wrote the post, my employer decided to post it on their site, so go here to view the post:

Remote Desktop to Ubuntu in Windows Azure

Update Azure DB Firewall Rules with PowerShell

noreply@blogger.com (Anonymous) — Wed, 27 Jun 2012 15:00:00 +0000

If you do Azure development and work from home like I do, you may find yourself repeatedly updating your SQL Azure Firewall settings to allow yourself to work with your database.

This is especially true if your crappy ISP repeatedly disconnects you throughout the day and assigns you new IP addresses. I don't want to disparage any company in particular, but I really hope there's some bandwidth competition on the horizon.
So, I wrote a PowerShell script to fix this problem. Now, I just say do the following:

Notice, the script checks the current rule and then replaces it, if needed. If it is not, it will say "Current Rule Is Correct".

In order to use this script, you will need to download and "import" the WAPPSCmdlets from CodePlex using "Import-Module".

You will also need to fill in the 4 variables at the top of the script. Note that the Certificate you use must be a Management certificate that is installed into the Azure Portal.

#TODO: set these up as parameters (with defaults)
$ruleName = 'Rule Name' #Whatever you want to see in the Azure UI for this Rule
$server = '' # the server name (without the ".database.windows.net" on the end)
$subId = '' # The Subscription ID
$cert = (Get-Item cert:\\CurrentUser\My\[YOUR KEY GOES HERE]) #the key is the "Thumbprint" - use "dir cert:\CurrentUser\My" to find yours

function RemoveRule()
{
    Write-Verbose 'Removing Firewall Rule'
    Remove-SqlAzureFirewallRule -ServerName $server -RuleName $ruleName -SubscriptionId $subId -Certificate $cert | Format-Table
}

function AddRule($myIP)
{
    Write-Output 'Adding rule for IP: ' + $myIP
    New-SqlAzureFirewallRule -StartIpAddress $myIP -EndIpAddress $myIp -ServerName $server -RuleName $ruleName -SubscriptionId $subId -Certificate $cert | Format-Table
}

## Function to retrieve external IP address.
## the external address is retrieved from the
## title header of the webpage "www.myip.dk"

function Get-ExternalIP {
    $source = "http://automation.whatismyip.com/n09230945.asp"
    
    $client = new-object System.Net.WebClient
    
    #add the header that whatismyip.com suggests from (http://www.whatismyip.com/faq/automation.asp)
    $client.Headers.Add('user-agent', 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:12.0) Gecko/20100101 Firefox/12.0')
    
    $client.downloadString($source)
}

function Update-AzureDBFirewallRules
{
    # get current IP.
    $currentIp = &Get-ExternalIP
    $rules = (Get-SqlAzureFirewallRules $server -SubscriptionId $subId -Certificate $cert)
    
    $curRule =  $rules | ? {$_.RuleName -eq $ruleName}
    
    $shouldAdd = $false

    if ($curRule -ne $null) {
        $ruleIp = $curRule.StartIpAddress
        if ($ruleIp -ne $currentIp ) {
        
            Write-Warning "Current IP [$ruleIp] is incorrect, removing Rule"
            &RemoveRule
            $shouldAdd = $true
        }
        else {
            Write-Output 'Current Rule is Correct'
        }
    }

    if ($shouldAdd -eq $true)
    {
        &AddRule ($currentIp)
    }
}

Hope this helps some of you out there...

Developing for, but remaining decoupled from Azure

noreply@blogger.com (Anonymous) — Thu, 17 May 2012 11:18:00 +0000

(This started out as a Yammer discussion post, but got obviously way too long for that, so I decided to blog it instead.)

A coworker had mentioned that there could be difficulty in developing for Azure while maintaining independence from it by decoupling from direct dependencies. Having done this from the beginning in my almost 2-year old Azure project, I decided to tell how I did this.

Why decouple?

First of all, why do we need to do this?

Well, I have developed for a very wide range of platforms in my past, including dozens of flavors of *nix, tons of versions of Windows (3.0, 3.1, 3.11, 95, 98, 98 SE, NT 3.X, 2000, ME, XP, Vista, Win 7), QNX, PSOS, OS/2, Mac OS, etc.

Given that, I've always had issues with tying my code too tightly to a platform. It always seems to come back and bit you. Hard.

Developing/Debugging

If you have ever tried to develop and debug with the Azure Dev Fabric, you probably didn't even ask this question in the first place.

Working with the Dev Fabric is painful, especially in the Web development side. Instead of being able to edit the HTML and JavaScript files while you debug, each edit requires a rebuild and redeploy.

If you're not familiar with this process, what is actually happening when you debug a "Cloud" app is a full deployment. Visual Studio is compiling the code, then, upon success, it packages a mini-azure deployment and deploys it to the Dev Fabric. This involves spinning up temporary Web Sites on your IIS installation and spinning up what are effectively mini Virtual Machines. So, in order to get any code changes over there, you must redeploy.

Bottom Line: no easy tweaks to your HTML, CSS or JavaScript while debugging.

Platform Independence

Sometimes, you may not have 100% buy-in from a client or a manager for running in Azure, so, in order to hedge your bets, you need to have the ability to run on Azure without depending on it, in case someone makes a decision to go the other way. Maybe the client hires a new CIO and he wants to run on Amazon because Jeff Bezos is an old college buddy. Crazier things have happened.

In my case, my project was, I believe, the first Azure project our company deployed into Production. Thus, we were hedging our bets a bit by allowing it to run on a regular on-premise deployment. This had the added benefit of allowing us to do pilot/demo deployments on-site for our client so they could view the site during early development.

What to decouple?

First off, there are three main areas that need to be decoupled in order to maintain your freedom, Configuration Settings, Images/Static Files and Data (SQL, etc)

CONFIGURATION SETTINGS

Regular .NET apps use AppSettings from either web.config or app.config for simple key/value settings. For this scenario, a simple interface will do:

public interface IConfigurationSettingsProvider
{
    string GetSettingValue(string key);
}

Non-Azure Implementation

using System.Configuration;

public class ConfigurationManagerSettingsProvider
    : IConfigurationSettingsProvider
{
    public string GetSettingValue(string key)
    {
        return ConfigurationManager.AppSettings.Get(key);
    }
}

Azure Implementation

public class AzureRoleConfigurationSettingsProvider
    : IConfigurationSettingsProvider
{
    public string GetSettingValue(string key)
    {
        return RoleEnvironment.GetConfigurationSettingValue(key);
    }
}

As you see, this isn't really all that complicated

IMAGES

In my case, the images we're serving up generally are based on an "Item Key" and can either be referring to a "normal" image size or a "thumbnail" image. We also needed the ability to store the images and retrieve them.

The implementation of my IImageStorage interface also actually takes care of scaling the images to the appropriate sizes during upload.

The particulars of your situation may vary, but the pattern could be similar.
NOTE: I removed a few overloads of methods here (for instance, each "Save" method has an implementation that takes a "Stream" and proxies it to the byte[] after reading the Stream in)

Interface

public enum ImageSize
{
    Thumbnail,
    Normal,
    Original
}
 
public interface IImageStorage 
{ 
    void SaveImage(int imageId, string pathInfo, byte[] imageBytes); 
 
    // removed overloads 
    // ... 
 
    Uri GetImageUri(int imageId, ImageSize size); 
 
    IEnumerable<int> GetAllImageIds();
 
    void DeleteImage(int imageId); 
}

Non-Azure Implementation

In this case, I chose to make a "FileSystemImageStorage" class that uses a directory structure of

Root->
Thumbs
Normal
Original

Each file name is the "ID" with ".jpg" in the end.

The urls returned are either "file:///" or "data://" (base64-encoded) urls based on the size.

Azure Implementation

For Azure, the pattern is very similar. I created a "BlobStorageImageStorage" class. I use 3 Blob Storage Containers called "normal", "thumbs" and "original" which each contain a blob with the image inside it.

In this case, I chose to make the name the ID zero-padded to 10 spaces in order to allow for long-term expansion. So, ID 1234 would be "0000001234". So, my url for the thumbnail for 1234 is:

http:// [accountname].blob.storage.net/thumbs/0000001234

DATA

For a "typical" application, data usually means SQL. In the case of SQL, the only difference as far as your application is concerned is a connection string, which is easy enough to abstract for yourself.

If, on the other hand, you are using Azure Table Storage, you will need to have some sort of Repository interface that will persist TableStorageEntitites for you.

In our application, we decided to allow the Entities to subclass TableStorageEntity, regardless of whether or not we're storing them to Azure.

Given that, we have this class (keep in mind that I've removed error checking, comments and a few other minor details - and the code patterning is kinda strange too in this format):

public class TableServiceEntityRepository<TEntity>
    where TEntity : TableServiceEntity
{
    readonly string _tableName;
    readonly TableServiceContext _context; 
    public TableServiceEntityRepository(
        ITableServiceContextFactory ctxFactory)
    {
        _tableName = typeof(TEntity).Name;
        _context = ctxFactory.Create(_tableName);
    }
    public IQueryable<TEntity> Get(
        Specification<TEntity> whereClause = null,
        Func<
        <TEntity>, IOrderedQueryable<TEntity>
            > orderBy = null)
    {
        IQueryable<TEntity> query =
            _context.CreateQuery<TEntity>(_tableName);
        if (whereClause != null)
        {
            query = query.Where(whereClause.IsSatisfiedBy());
        }
        if (orderBy != null)
        {
            return orderBy(query);
        }
        return query;
    }
    public virtual void Insert(TEntity entity)
    {
        _context.AddObject(_tableName, entity);
    }
    public virtual void Update(TEntity entity)
    {
        var desc = _context.GetEntityDescriptor(entity);
        if (desc == null || desc.State == EntityStates.Detached)
        {
            _context.AttachTo(_tableName, entity, "*");
        }
        _context.UpdateObject(entity);
    }
    public virtual void Delete(TEntity entity)
    {
        var desc = _context.GetEntityDescriptor(entity);
        if (desc == null || desc.State == EntityStates.Detached)
        {
            _context.AttachTo(_tableName, entity, "*");
        }
        _context.DeleteObject(entity);
    }
    public virtual void SaveChanges()
    {
        _context.SaveChanges();
    }
}

If you notice, this code uses a Specification for a "whereClause". That is defined this way:

public abstract class Specification<TEntity>
{ 
    private Func<TEntity, bool> _compiledFunc = null; 
    private Func<TEntity, bool> CompiledFunc 
    { 
        get 
        { 
            if (_compiledFunc == null) 
                _compiledFunc = this.IsSatisfiedBy().Compile(); 
            return _compiledFunc; 
        } 
    } 
    public abstract Expression<Func<TEntity, bool>> IsSatisfiedBy();
 
    public bool IsSatisfiedBy(TEntity entity) 
    { 
        return this.CompiledFunc(entity); 
    } 
}

The non-Azure version of this just uses the TableServiceEntity's PartitionKey and RowKey fields for folder name and file name and uses Binary Serialization to serialize the files. It's pretty simple, but wouldn't work for very large numbers of entities, of course. You could, however choose to do the same thing with SQL Server using a SQL Blob for the serialized data for a quick speed improvement.

Though we have other implementation abstractions in our software for things like Queues, this should give you a good kick start on how things are done.

Summary

Abstracting things from specific hardware/platform dependencies is usually a Good Thing in my opinion. Stuff Happens. Platforms break/die/become uncool, etc. We shouldn't have to refactor significant portions of applications in order to be more Platform agnostic.

Feel free to comment or contact me for more details on how things like this can be done, or any questions on my implementation of the Specification pattern or anything at all :)

Solution to 0x80007002 error installing Zune 4.8

noreply@blogger.com (Anonymous) — Fri, 20 Apr 2012 14:34:00 +0000

I just bought a Nokia Lumia 900 only to find that Microsoft took a page from Apple's book and required the installation if iTunes Zune software in order to upgrade the phone. Ugh!

So, I download the installer and, of course, get 0x80007002 error installing the software. It tells me:

The media for installation package couldn't be found. It might be incomplete or corrupt

Uh… What? It's a Self-Extracting EXE!

Here's what I tried:

Download the "full version" (first one downloaded the installer to temp files) – FAIL
Ran a Microsoft "FixIt" app that was supposed to .. you know.. Fix It? – FAIL
Turned off the Firewall – FAIL
Yelled at the Screen – FAIL
"Unblocked" the EXE file and re-ran the installer – FAIL
Decided to get insanely stupid and unzipped the file myself and ran the contained installer – Success!? (*facepalm*)

Whiskey. Tango. Foxtrot?

Apparently their "self-extracting" EXE is not very good at the job. Can't blame them, since self-extracting zip files is a really recent innova--- Wait! That technology has existed for decades!!

Come on guys! Maybe you need a refresher course!
("It's all ball bearings nowadays!")

So.. if you run into this, just unzip the thing your damned self and call it a day!

JsTrace 1.3 Released

noreply@blogger.com (Anonymous) — Sun, 18 Mar 2012 13:22:00 +0000

Get it while it's hot!

I just added a few features to the JsTrace code:

New passthrough methods on the Trace object for the following: assert, clear, count, dir, dirxml, exception, group, groupCollapsed, groupEnd, profile, profileEnd, table, time, timeEnd, trace

Note that the Trace script does nothing but pass these through if they exist

Ability to get/set the default trace level with the Trace.defaultTraceLevel method
Ability to reset some or all of the currently configured trace levels to the defaults by calling the Trace.resetToDefault method.
New Jasmine tests to make sure it works (mostly)

On the MVC side, I added a feature to the JsTrace.MVC package:

The ability to force logging to the server to be synchronous in order to preserve the order of messages coming back to the server.

It was either that or adding message numbers, and this was quicker.

NuGet packages are updated:

http://nuget.org/packages/jstrace

http://nuget.org/packages/jstrace.mvc

Or browse the code here: http://jstrace.codeplex.com/

Happy debugging!

Disable Minification with MVC 4 Bundles

noreply@blogger.com (Anonymous) — Sat, 17 Mar 2012 20:33:00 +0000

I decided to play around with a bunch of new technologies to dive in and learn today. I decided to write a basic blog app (yeah, boring, I know) using the following tools:

Visual Studio 11 Beta
ASP.NET MVC 4 Beta

Single Page Application
Bundles (new combining/minification stuff)
Web API

Twitter Bootstrap 2.0
Modernizr
MvcScaffolding
etc…

(TL;DR? Click Here)

The Problems

Everything was going well, adding NuGet packages left and right (click, click, click!)
I added my JsTrace MVC NuGet package and started to get JavaScript errors.It turns out that I had 2 problems with the Bundles feature:

It doesn't add anything to the Bundles automatically except the original scripts in the Template.
It automatically uses minified files by looking for "min" or not "debug" JavaScript or CSS files.

Fix #1 - Add my own Bundles

Grr! To fix #1, I had to add my own Bundle to the Global.asax:

Bundle tomsBundle = new Bundle("~/core/js");
tomsBundle.AddDirectory("~/Scripts", "Trace*", false, true);
tomsBundle.AddDirectory("~/Scripts/Core", "Foo.*", false, true);
BundleTable.Bundles.Add(tomsBundle);

OK, problem solved.

Fix #1a - Bootstrap Bundles

While I was there, I decided to make an extension method to add the Twitter.Bootstrap stuff to the BundleTable:

public static class BootstrapExtensionMethods
{
    public static void EnableBootstrapBundle(
        this BundleCollection bundles)
    {
        var bootstrapCss = new Bundle("~/bootstrap/css", 
            new CssMinify());
        bootstrapCss.AddDirectory("~/Content", "bootstrap*", 
            false, true);
        bundles.Add(bootstrapCss);
 
        var bootstrapJs = new Bundle("~/bootstrap/js", new JsMinify());
        bootstrapJs.AddFile("~/Scripts/bootstrap.js");
        bundles.Add(bootstrapJs);
    }
}

So, add a one-liner to the Global.asax:

BundleTable.Bundles.EnableBootstrapBundle();

Fix #2 - Supersize Me!

Now, for Problem #2 – I want to have big, fat un-minimized debug versions of my files while I'm developing. So, after digging around with Google and ILSpy, I came across the implementation of JsMinify and noticed that it uses a property called "EnableInstrumentation" to determine whether or not it should minify the files. Eureka!

Of course, they don't actually provide you with a simple way to set that flag. So, I realized I had to create my own implementation of 2 interfaces:

IBundleBuilder - has the responsibility for iterating over a collection of files and combining them
IBundleTransform – has the responsibility of "transforming" (i.e. minifying) the bundles (default implementations being JsMinify and CssMinify)

So, I created two wrapper classes (basically, the Decorator Pattern):

NonMinifyingBundleBuilder – reverses Microsoft's logic and replaces the minified files with their debug counterparts.
InstrumentedBundleTransform – sets the "EnableInstrumentation" flag to true while processing.

I then added a simple extension method to override everything in the BundleTable:

BundleTable.Bundles.DisableMinify();

This is probably best wrapped in an "#if DEBUG" so your release code still gets all minified.
In fact, that's what I do in the NuGet package I created out of this!

NOTE: this is a beta (since it relies on Microsoft.Web.Optimization 1.0.0-beta), so you will have to install the NuGet package with the NuGet Package Console like this:

PM> Install-Package McKearney.BundlingTweaks -Pre

How To: Download Azure Publish Settings File

noreply@blogger.com (Anonymous) — Thu, 15 Mar 2012 12:28:00 +0000

So, as of Azure SDK 1.6 (I think), Microsoft added the ability to import your publishing settings for Azure into Visual Studio to make deployments easier

This then launches your browser and has you login to your Live account.
Then, it downloads the file automatically and imports it, saving you time.
I installed Azure Diagnostics Manager Version 2 and it has a neat feature to allow you to import a Publish Settings File. So, off I went to try to download it. I found NO documentation on how to get it.
By some spelunking through browser history, I found this magical link:

https://windows.azure.com/download/publishprofile.aspx

This will allow you to download the file and do whatever you want with it, including import it into ADM.
WARNING: This has sensitive information in it to allow you to publish to your Azure account. I recommend you delete this file after you import it into ADM

Quick Tip: VirtualBox Win 8 Custom Resolution

noreply@blogger.com (Anonymous) — Sun, 11 Mar 2012 13:20:00 +0000

I'm not sure what the true root cause of the problem is, but, when running Windows 8 Customer Preview in VirtualBox, the set of allowed resolutions is pretty pathetic.

I don't even know where / why anyone would buy a 4:3 ratio monitor anymore, so I don't know why there aren't a bunch of supported 16:9 options in here.

In order to get around this, there's a command that, though simple, needs to be done from the command line (after shutting down your virtual machine)

So, if you go to your Virtual Box Folder (usually C:\Program Files\Oracle\VirtualBox) and run the following command, you should be OK:

Then, when you go back into your machine, you should see the new resolution listed for use.

I'm not sure how to make this resolution available in every subsequent virtual machine, but I'm glad it's available in this one.

Thanks to Dustin over at http://mstechpages.com for what amounts to all this information in this article

Released: JsTrace.MVC

noreply@blogger.com (Anonymous) — Sun, 04 Mar 2012 13:30:00 +0000

I just released the JsTrace add-on JsTrace.MVC as a NuGet package.

What is it? It's a way to automatically proxy JsTrace messages from client-side JavaScript to your MVC application.

Basically, when you add this package, you get the following Area added to your ASP.NET MVC project:

The JsTraceController has a single "Index" method that receives a JsTraceMessage object. All that contains is the module, level and message sent from the JavaScript side.
Given the following javascript:

var tracer = new Trace('TestModule');
tracer.error('testing: error message');

The default implementation just outputs to the console using Debug.WriteLine:

   JsTrace >> [error] Module 'TestModule' : testing: error message

All you need to do is use the included HtmlHelper extension method like this, depending on your syntax:

<%: Html.RenderJsTraceProxy() %>

@Html.RenderJsTraceProxy()

By default, the rendered script will proxy only messages that pass the “switch test”. If you pass “true” in the RenderJsTraceProxy(), it will send all of them, which might be a bit crazy in production.

The script uses the jQuery $.ajax() method to post a JSON object to the server asynchronously -- ignoring success or error as well.

I may have a follow up version that has more options for the Proxy, like being able to pass a predicate-style (returns boolean) method to determine whether or not to send the message to the server. This way you could customize the logic yourself.

Check it out, and let me know what you think!

T

JsTrace 1.1.1 released

noreply@blogger.com (Anonymous) — Mon, 27 Feb 2012 13:17:00 +0000

So, I released a new version of the JsTrace project.

This version basically includes rewriting things to be a little more "proper" in the JavaScript side of things.

I removed things like the "with" keyword (reimplemented just using basic closure technique)
Turned on/Fixed a lot of JSHint restrictions (though I still don't dig the "use one var statement" thing, so I don't follow that – it's totally unnecessary in my opinion).
Updated the Intellisense comments so that we have as much info in client code as possible
Updated source code to have a test project and the NuGet package generation in it.

So, if you're using the NuGet package, you'll just get the update automatically, otherwise, go snag it on Codeplex: http://jstrace.codeplex.com

Happy Debugging!

Tom

Released: JsTrace - My JavaScript Diagnostics Module (NuGet Package too!)

noreply@blogger.com (Anonymous) — Sat, 18 Feb 2012 17:12:00 +0000

I've been planning on this for a while, but, after my original post post about JsTrace, I wanted to make it easier for people to get to and use.

So, first of all, I added JsTrace to CodePlex.

Then, I wrote some pretty decent documentation for it.

Finally, I published it as a NuGet Package.

Use it at will and spread the word!

Just Published: TFS Solution Info - Visual Studio Extension

noreply@blogger.com (Anonymous) — Thu, 09 Feb 2012 02:37:00 +0000

The Problem

I deal with Team Foundation Server (TFS) a lot day to day, so I occasionally find myself wondering which Branch and/or Workspace I happen to have open on my project at any given time. For some people, this is not a problem, since they work on one particular branch, do their work and then check in. For me, though, it’s different.
I do parallel development on my project. Sometimes I’m working on a great new feature for 2.0 while switching over to a HotFix branch to do a quick patch for the 1.5 version that’s in Production.
I also use a separate workspace in TFS to Merge and deploy code. Throw in the “Experimental” Workspace I use to play around in various versions of the code, and you can see why I frequently get lost.

The Solution

(no pun intended! -- OK, I confess: It was totally intended!)
Banking on the theory that I’m not alone in this – and, based on my coworker feedback, I’m not – I decided to publish the Visual Studio plugin I created.
For lack of a better name, I called it “TFS Solution Info”
Here’s what it looks like

It’s pretty simple. Using the Visual Studio SDK, I connected up to Solution events and TFS-related information to display information about the currently loaded Solution.

I can’t believe how useful this has been for me. I hope it’s useful for you too!

Get TFS Solution Info from the Visual Studio Gallery!

Or, you can just search for “TFS Solution Info” in the Visual Studio Extension Manager. The code will be posted up on Codeplex very soon.

Let me know what you would like to see this do.

[Update: just updated the formatting]

Pro Tip: Code Analysis, IoC and Excessive Class Coupling

noreply@blogger.com (Anonymous) — Fri, 03 Feb 2012 16:34:00 +0000

This is a quick tip:

If you’re using Visual Studio's Code Analysis to make your code better (and who isn’t?), you’ll obviously have a bit of a problem with any IoC bootstrapping because you’re most likely wiring up a LOT of interfaces and classes together in your bootstrapping logic.

This will result in the CA1506 "Avoid Excessive Class Coupling" warning

SuppressMessage to the rescue!

Just decorate your IoC bootstrapper class or method with this:

[SuppressMessage("Microsoft.Maintainability",
   "CA1506:AvoidExcessiveClassCoupling")]
public static class IoC
...

Problem Solved!

Debug.Assert() – So, what about Release Mode?

noreply@blogger.com (Anonymous) — Sun, 29 Jan 2012 19:26:00 +0000

Sometimes, as a developer, you create some little nifty tool to make life easier and you forget that other people may not have come up with that idea/solution and are still struggling with a problem you solved ages ago.
I was having a Skype conversation with Pete Brown and he said “Why don't you blog this stuff, or set up a GitHub project or something with these things?”. I told him, “well, actually, I just started blogging!”
That conversation gave me a figurative kick in the tuchus, so I decided to share a small nugget.

Defensive Development

If you know me you know that I am a big fan of code instrumentation and “defensive development”. I think it’s the best way to protect yourself. To me, developing defensively means that you are doing the following in your code:

Checking all your assumptions
Checking all your parameters for null or incorrect values
Verifying things like loop invariants, preconditions, postconditions, http://en.wikipedia.org/wiki/Code_contract, etc

Generally, you’re trying to “bullet-proof” your code.
Given that I think like this, I tend to use debug assertions a lot.

Debug.Assert

If you’re not familiar with Debug.Assert, it basically takes a boolean condition representing an “assertion” or assumption you are making at that point in your code. It also takes an optional message that will be displayed on a modal dialog if the assertion fails. The “Debug” part tells you that it will only run in Debug mode. Essentially, internally, the implementation is wrapped in "#if DEBUG” conditional compilation.
So, Debug.Assert is useful, but, what about Release mode?

What about Release Mode?

Well, in the realm of good, solid development, where you test everything thoroughly and have a long, drawn-out testing period before you deploy, Debug.Assert does the job well while not slowing down the executing code in deployment.
I think this is Utopian in this day and age.
For the large majority of developers, extreme performance is not a problem. A few exceptions would be developers who work on:

BIG games (not words with friends, more like Call Of Duty)
Operating Systems
Low-level Device Drivers

I’m sure there are a few more, but most of us work on Business Applications. These applications don’t usually have extreme performance needs where a few extra “if” statements will be a problem.

Release.Assert?

Well, Debug.Assert pops up a dialog in the middle of a debugging session. This is obviously not practical in Release Mode, since the user is most likely not a developer and is most likely not running the app inside Visual Studio.
Of course, you wouldn’t run Debug code in Production either… Right? RIGHT?
So, our only option is Exceptions.

My Solution

Well, since I don’t want to lose the nice Debug.Assert functionality of stopping my execution as it runs in debug mode, I decided to implement my solution in terms of Debug.Assert. So, we have these requirements:

continue to utilize Debug.Assert
In Release Mode, throw an exception instead.
Allow for custom exception usage (can’t just throw one kind of exception)

So, we have the following method:

[SuppressMessage("Microsoft.Design", "CA1004", Justification = 
  "This method instantiates and throws the exception, it can't be passed in")]
[DebuggerStepThrough()]
public static void AssertThrow<TException>(bool condition, 
   string failureMessage) where TException : Exception
{
    Debug.Assert(condition, failureMessage);
    if (condition == false)
    {
        // throw exception here...
    }
}

The [SuppressMessage] is there in case you’re running Code Analysis. The analysis tools don’t like that the method is using a generic type that’s not part of the rest of the function signature.

The [DebuggerStepThrough] just makes it so that it steps over this as if it’s one execution statement when debugging.

The Debug.Assert line is rather obvious, so I’ll skip that.

The "where TException : Exception" part forces the type you specify to be a derived class of System.Exception, so it can be thrown.
The next section is where we throw the exception.

ConstructorInfo ctor = typeof(TException).GetConstructor(
   new Type[] { typeof(string) });
TException ex = (TException)ctor.Invoke(new object[] { failureMessage });
throw ex;

I’m using Reflection to get the constructor of the TException object that takes one string. Then, I am invoking that constructor with the failureMessage and throwing the exception.

So, all you do is call it like this:

void Foo(Bar bar)
{
    Diag.AssertThrow<ArgumentNullException>(
        bar != null, "Duh, Foo needs a Bar!");
        
    // use bar here.
}

Teh Codez

Here is the complete listing without all the line wraps and with comments. Once I set up a paid Github account or something like that, I’ll start moving code elsewhere:

using System;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;

namespace McKearney.Common.Diagnostics
{
    /// <summary>
    /// Utility class that contains Diagnostic- and Instrumentation-related methods
    /// </summary>
    public static class Diag
    {
        #region Static Operations

        /// <summary>
        /// Asserts and then throws, making sure that the error gets handled by client code
        /// </summary>
        /// <typeparam name="TException">The type of the exception to throw.</typeparam>
        /// <param name="condition">the asserted condition</param>
        /// <param name="failureMessage">The failure message.</param>
        [SuppressMessage("Microsoft.Design", "CA1004", Justification = "This method instantiates and throws the exception, it can't be passed in")]
        [DebuggerStepThrough()]
        public static void AssertThrow<texception>(bool condition, string failureMessage) where TException : Exception
        {
            Debug.Assert(condition, failureMessage);
            if (condition == false)
            {
                ConstructorInfo ctor = typeof(TException).GetConstructor(new Type[] { typeof(string) });
                TException ex = (TException)ctor.Invoke(new object[] { failureMessage });
                throw ex;
            }
        }
    }
}

Leave me a comment, I'm curious what your thoughts are.

My project featured as a Microsoft Case Study

noreply@blogger.com (Anonymous) — Sat, 28 Jan 2012 13:30:00 +0000

It’s kind of neat seeing your own project featured as a Microsoft Case Study.

Of course, now I want to update it with more information, since a lot has happened since we gave them all that information. The project has actually had a direct effect on the company’s quarterly profits and is now going to be rolled out internationally (in phases).

Anyway, wanted to pause to toot my own horn for a sec. Toot! Toot!

Live.com password idiocy

noreply@blogger.com (Anonymous) — Sat, 28 Jan 2012 13:14:00 +0000

Back Story

I use Keepass to maintain all my passwords. Then, I have this password database stored in a USB key I carry with me. I only have to remember one highly-entropic password (doesn’t mean it’s hard to remember, it just has to be hard to guess). So, I try to make my other passwords as complicated as possible.

Changing My Password on Live.com

Anyway, I went to change my password on live,com like I prefer to do on a semi-regular basis. I got to their page and entered a new password. I tried one that was 256 characters long, but I noticed that, with no warning at all, it truncated my password at 16 characters.
So, they have a minimum of 6 characters (which is on the page) and an apparent maximum of 16 characters. So, I changed the options to generate a 16-character password with all sorts of variability in the characters used and I try again: (This time it was: “{j/ýQîÔ·z4Ú«<[“)
Now, I get this lovely message:

What’s Missing?

Apparently, the powers that be at Microsoft (Live.com) aren’t going to bother telling me what characters are and are not allowed! So, what? I just sit here and guess for hours?
I was reminded of this great xkcd comic. This is not security! It’s obscurity. Making a person choose a password within 6-16 characters with a fixed subset of characters allowed just trims down the dataset that a computer needs to search while trying to crack the password. At the same time, requiring special characters (but not that special!) to be there in order to make it strong just makes it harder for humans to guess with the wonderful side effect of also making them nearly impossible to remember!
Well, I’m going to go keep trying passwords over and over again until I find one it will allow…ugh

ASP.NET MVC OutputCache override

noreply@blogger.com (Anonymous) — Thu, 26 Jan 2012 16:49:00 +0000

IE Strikes Again!

Because of my recent discovery of the IE9 “feature” that makes it cache unlike every other browser, I had to come up with a small change to our caching scheme on my project. To be fair, the IE9 team is actually well within RFC definitions of how to handle “cache-control: private”, so I shouldn’t complain too much about it. Though, why is it always IE that causes me to do extra coding?

Anyway, my solution was to add a “Default” OutputCache setting for all my MVC Controllers and then, to override these options on individual Controller Actions when needed. The problem is: I can’t find any information on whether or not an OutputCache directive on an Action will override one on the Controller.

So, I wrote a quick test app to test it out.

The Code

    // default everything to a tiny cache time
    [OutputCache(CacheProfile="ShortCache")]
    public class HomeController : Controller
    {
        public ActionResult Index()
        {
            ViewBag.Message = "Welcome to ASP.NET MVC!";
            return View();
        }

        // change to a longer cache time
        [OutputCache(CacheProfile = "LongCache")]
        public ActionResult About()
        {
            return View();
        }
    }

Web.config mods

  
<system.web>
      <caching>
        <outputcachesettings>
          <outputcacheprofiles>
            <add duration="1" name="ShortCache" varybyparam="*">
            <add duration="60" name="LongCache" varybyparam="*">
          </add></add></outputcacheprofiles>
        </outputcachesettings>
      </caching>
  </system.web>

Results

Well, What do you know!? It worked! Hopefully someone else stumbles across this and saves themselves some time.

Silverlight 5 Toolkit, 3D and crappy installers..

noreply@blogger.com (Anonymous) — Mon, 16 Jan 2012 15:11:00 +0000

I'm in the rather ~~grueling~~ awesome process of tech reviewing my friend Pete Brown's new book, Silverlight 5 In Action. As a part of that, I had to get setup with the Silverlight 5 Toolkit in order to get the new 3D templates.

Frankly, I'm rather excited at the prospect of playing around with 3D stuff in Silverlight. We've come a very long way since the days of just displaying simple things like a clock in a browser plugin.

So, I install the toolkit and start up Visual Studio 2010 and choose a Silverlight 3D Application

I called my project “Silverlight3dExample”. Now, Visual Studio fires up the hamsters in their wheels and all the other rube goldberg-esque machinations inside and comes up with this lovely tandem of errors:

So, after a bit of googling, I realized, much to my chagrin, that I neglected a rather important notice on the screen of the Toolkit:

Note: You must install XNA Studio in order to use the new Silverlight 3D templates.Otherwise the new templates will not show up.

Oh.. uhh.. oops. Seems kind of odd that such a big missing prerequisite isn’t also detected by the installer, but, whatever…

So, I download XNA studio and install that… more whirring, banging from my machine ensues. Then, just in case things won’t recover gently, I decide to create the solution from scratch again. After all, I hadn’t done anything yet.

Woohoo! all 4 projects successfully created!

Sweetness, right!? So, I hit Ctrl-Shift-B (build command for you mouse-using pansies out there) and voila, everything builds! Just kidding! Now, I get this obvious and very helpful error:

Compile error -2147024770
(0, 0): error : Unknown compile error (check flags against DX version) D:\Dev\Book…Silverlight3dExample\Silverlight3dApp\CustomEffect.slfx

Umm.. OK.. Googling… googling… uh… yeah… Apparently, there’s another prerequisite missing that the installer also doesn’t check for: DirectX 9. So, I download that and install (cringing at every single “installing XX update from 2006” message – how can that really not break my machine?).

Finally, it actually builds! No thanks to the Silverlight Toolkit guys (well, some thanks, since they wrote it in the first place!), I can now continue to review this chapter of what really is a pretty killer book, you should buy it. Now.

Yes, I'm 12...

noreply@blogger.com (Anonymous) — Tue, 10 Jan 2012 21:01:00 +0000

So, I moused over my explorer windows on my taskbar and this popped up:

Yep.. giggled like a 12 year old and told my friends about it :)

JavaScript Globalization

noreply@blogger.com (Anonymous) — Thu, 22 Dec 2011 11:39:00 +0000

I am leading a project that is now going to go from running in the US to running across the world over the next 6+ months.

It currently uses a lot of different tech: ASP.NET MVC3, HTML5, jQuery, jQuery UI, KnockoutJs (w/Mapping), jQuery Templates, jQuery DataTables, EF4 and a host of other home-grown and one-off type technologies.

So, I started browsing the usual suspects, especially a previously bookmarked Scott Hanselman blog post (suspiciously a 7-month-old "part 1" with no "part 2" yet *holds breath*).

Well, the most confusing part I have run across so far is how to handle JavaScript and jQuery globalization. There was one project by Microsoft that was donated/accepted/rejected by the jQuery folks (sounds familiar... jQuery Templates had the same problem) which, apparently went through a few renamings (one, two, three), the last of which was a renaming to "Globalize", total api change and removal of any dependency on jQuery (not sure if there was ever one, but didn't bother to get into it).

Confusingly, this library (not a plugin anymore) is maintained/developed by the jQuery UI team now, even though there's no dependency.

So, apparently, the supported(?), in-development code is now the "Globalize" library whose wiki is here (on the jQuery UI site, where else? ... O_o)

Hope that helps save someone else some time.

Chain Of Responsibility Implementation

noreply@blogger.com (Anonymous) — Sat, 19 Nov 2011 17:50:00 +0000

I was reading my twitter feed and came across a retweet from Glenn Block. The original was from Anoop Madhusudanan which pointed to his blog post called “Implementing Chain of Responsibility Design Pattern in C# using Managed Extensibility Framework (MEF)”. It sounded very interesting, so I dug in.

[UPDATE: I have since updated this post. Look for the block at the bottom]\

The Problem

Anoop’s Chain Of Responsibility example starts with this:

//Request
class LoanRequest  
{  
    public string Customer { get; set; }  
    public decimal Amount { get; set; }  
}  
  
//Abstract Request Handler  
interface IRequestHandler  
{  
    string Name { get; set; }  
    void HandleRequest(LoanRequest req);  
    IRequestHandler Successor { get; set; }  
}

[Insert record-scratch sound here]
I couldn’t get past this part without writing this blog post.
Can you see the problem? … No? Let me give you a hint:

//Abstract Request Handler
interface IRequestHandler  
{      
    string Name { get; set; }      
    void HandleRequest(LoanRequest req);     
 
    ------======>>>  
    ------======>>>  IRequestHandler Successor { get; set; }
    ------======>>>  
}

WAIT! Hold on! Why does the IRequestHandler know about its successor? Why would I, as a consumer of an IRequestHandler want access to its successor? To me, there is no part of IRequestHandler’s responsibility that involves knowing about and/or forwarding on a request to some other instance of itself.

The Solution

I prefer more of a MVA/DMV mentality for the IRequestHandler
(“It’s not MY Job, go somewhere else!”)

// New Request Handler  
interface IRequestHandler 
{ 
    string Name { get; set; } 
    bool HandleRequest(LoanRequest req); 
}

In this approach, the HandleRequest method returns a boolean telling whether or not it actually handled the request.

And Another Thing

One other flaw of Anoop’s approach: if the request makes it all the way through the chain and doesn’t get handled, we have no indication that it was not handled. In the new approach, we get a nice, pleasant boolean value.

What Am I Forgetting?

Wait, you say? What about the Chain Of Responsibility? I don’t see any Chain and you promised me a Chain!

Oh …. yeah… ok..
So, now that the interface makes me feel all warm and fuzzy, we need to implement the Chain Of Responsibility pattern. I prefer to implement the Chain Of Responsibility in terms of a variation on the Composite Pattern:

class ChainingRequestHandler : IRequestHandler
{
    private readonly IEnumerable<IRequestHandler> _handlers;
    public ChainingRequestHandler(IEnumerable<IRequestHandler> handlers)
    {
        _handlers = handlers;
    }

    public string Name { get; set; } 

    public bool HandleRequest(LoanRequest req)
    {
        // iterate of the chain
        foreach(IRequestHandler handler in _handlers)
        {
            if (handler.HandleRequest(req) == true)
            {
                // it was handled
                return true;
            }
        }
        // no such luck
        return false;
    }
}

Conclusion

By using the a variation on the composite pattern, we allow the client code to use the nice, simple IRequestHandler without any knowledge of the underlying complexity of implementation, or that there’s even a Chain Of Responsibility at all.

I don’t know about you, but that warms the cockles of my development heart.
Now, doesn’t that feel better?
Now, I think I should go read the rest of that article!

[UPDATE]
So, after I blogged about it and whined on Twitter, I finished the rest of the article, which was a nice application of MEF to the pattern. I also read some other MEF-related posts on Anoop's blog, which were also informative. I exchanged a few tweets with Anoop as well.

I should point out that Anoop's implementation is actually exactly what the Chain Of Responsibility pattern is supposed to be (I'm suspecting the void return value was just a bug/oversight). My actual problem is with the Chain Of Responsibility pattern itself.

From a business perspective, I understand the idea of knowing the "successor" in the chain. In this instance, of course the Cashier knows who her Manager is at a given time, but:

What happens when there's a shift change?
What happens if there are two Managers in the office?
What happens if there are zero Managers in the office?

I just feel that the stock pattern limits the implementation too much. I also believe that my approach, while handling the stock Chain Of Responsibility goals well enough also has added benefits.

First, It adds an implementation abstraction from the client code. The user of IRequestHandler does not need to know about Successors or anything else like that. In stead of having client code talk to a class that then talks to the Chain, the Chain can be handed back to the client code in the form of the simple interface.

Secondly, given this new abstraction, it simplifies the interfaces while allowing a greater abstraction for the Chaining. Thus, the developer can implement some sort of Factory/Bootstrapping/IoC implementation for creating the Handler used by the client code. This way, the Chain ordering can be redefined, the Chain can be replaced with a Directed Graph or a Workflow without the client code OR the IRequestHandler-derived classes being any the wiser.

So, my secondary conclusion here is: Anoop didn't do anything wrong, it's just that the Chain Of Responsibility pattern should really have 1 extra level of abstraction in it to make it as flexible as possible.

Hmm.. which one’s broken, Linq, Debugger, IDE?

noreply@blogger.com (Anonymous) — Mon, 07 Nov 2011 19:06:00 +0000

So, I ran into an as of yet unsolved problem today. I don’t know if this is a Linq bug, a debugger bug, or a Visual Studio bug, but, for your viewing pleasure:

If I can figure out what’s going on, I’ll post an update

EDIT: Figured it out..

This is one of the big reasons I don’t like operator overloading…

The items inside the FilterList overrode the comparison operators, but did not handle “null” properly…

Grrr..

CSS Transform help

noreply@blogger.com (Anonymous) — Thu, 03 Nov 2011 10:49:00 +0000

Just a quick blurb here...

I decided to try to do some fancy CSS stuff for my client website. It involves gradients, transforms and stuff like that. Anybody who's messed with that stuff knows that it's a huge pain in the butt to get it working in all the browsers, never mind one! So, here you go: http://css3generator.com/.

You're welcome :)

Windows Azure AppFabric Cache's Miniscule Features

noreply@blogger.com (Anonymous) — Wed, 26 Oct 2011 14:20:00 +0000

Just wanted to warn/inform people who are considering using AppFabric Caching in Azure…

Here’s a list of things it won’t do:

Regions
Named Caches
Allow you to get a list of cache keys currently in use
High Availability Mode (redundant copies across machines for durability)
No sliding window expiration
No events for things like eviction, add/remove, etc.

so you can’t update a local cache with events from the global cache
You don’t get notified if something is removed, so you only know when you get “null” back from a Get()

No Powershell integration (if you’re into that)
No tag support (tagging is basically used for some extra metadata besides the key without pulling the whole object)

So, basically, ALL you get is a simple, Get/Set distributed cache that doesn’t even support the whole set of features you get from the basic ObjectCache in .NET 4.0

They really shouldn’t be calling it “AppFabric Cache” at all, since it doesn’t really support anything that comes with that API

I must say that I’m really disappointed

We waited a LONG time for this feature and got something that could have been coded in a month.

Bad form, Microsoft. Bad form!

Conflicts Between Versions Of Assemblies

noreply@blogger.com (Anonymous) — Wed, 26 Oct 2011 14:00:00 +0000

I just upgraded a project from the Azure SDK 1.4 to SDK 1.5. I started getting the "Found conflicts between different versions of the same dependent assembly" warning on the Microsoft.ServiceBus.dll file.

I thought to myself, "Self, I've seen this before. You're just referencing the wrong copy of an assembly somewhere"

So, I checked every reference to Microsoft.ServiceBus.dll … Hmm… they're all correct. ??

I did a full rebuild… still there..

I did a super-duper clean (close the project, delete every "bin" and "obj" folder, open the project and rebuild)… nope…

Time to get medieval on this stuff… So, I opened the topmost assembly (in this case, my Web application assembly) in ILSpy. I stared looking through each and every referenced assembly until I found the culprit:

Microsoft's own Transient Fault Handling library (used for retrying database calls in Azure). Now, I've contacted the team who wrote that, hoping that they will update their NuGet package. Otherwise, I'll have to add that ugly Binding Redirect in my config file.

For now, I'll just stare at the warning for a while and hope the NuGet package gets a quick update