HutchCodes

App Settings in Client-Side Blazor

Jeremy Hutchinson — Tue, 17 Dec 2019 00:00:00 UTC

I’ve been spoiled by Asp.Net and expect app settings to just work, but there is no easily configured app settings story for client-side Blazor yet. What I’m looking for is the ability to set some settings on a per-environment (dev/test/beta/prod) through Azure App Service Application Settings. The goal is one build artifact that moves from environment to environment with zero changes.

If you host the Blazor app as static files you’d need to change the app settings file for each different environment. So, I’ve gone with Asp.Net Core Web Hosted. I’ve named the app AppSettingsExample, so in the solution we have AppSettingsExample.Client (the WASM app), AppSettingsExample.Server (the host app), and AppSettingExample.Shared (code that is shared between the Client and Server)

Loading Client App Settings

We’ll store and access the client app settings through the built-in configuration in AppSettingsExample.Server. To do that we’ll add an appsettings.json with the following values.

{
  "ClientAppSettings": {
    "BaseApiUrl": "http://somesite.com/api"
  }
}

We’ll also create a class in the AppSettingsExample.Shared project to hold those configurations.

public class ClientAppSettings
{
    public string BaseApiUrl { get; set; }
}

Then in the AppSettingsExample.Server’s Startup we’ll get a reference to the application’s configuration and store it in a local variable.

private readonly IConfiguration _configuration;

public Startup(IConfiguration configuration)
{
    _configuration = configuration;
}

This allows us to use that config to load the settings from appsettings.json and add it to the dependency injection config as a singleton.

public void ConfigureServices(IServiceCollection services)
{
    services.AddSingleton(_configuration.GetSection("ClientAppSettings").Get<ClientAppSettings>());

Exposing the Settings to the Client

There isn’t an easy way to just pass the settings into the client-side Blazor app, so we’ll need the app to request them from the server. We’ll create a ClientAppSettingsController to AppSettingsExample.Server to serve up these settings.

[Route("api/[controller]")]
[ApiController]
public class ClientAppSettingsController : ControllerBase
{
    private readonly ClientAppSettings _clientAppSettings;

    public ClientAppSettingsController(ClientAppSettings clientAppSettings)
    {
        _clientAppSettings = clientAppSettings;
    }

    [HttpGet]
    public ClientAppSettings GetClientAppSettings()
    {
        return _clientAppSettings;
    }
}

Getting the Settings from the Client

This is where I had the most trouble. I need to completely load these settings before the application can move on. If I did it asynchronously, it would start running the Initialization and ParameterSet methods on the current page before the settings load completed. If I tried to force the asynchronous web request to complete synchronously by calling .Wait(), the application locked up.

To get around this we can create a component that loads the settings and once loaded displays its child content. Then we can wrap our content in this component to make sure it doesn’t start initializing or setting parameters until the settings are loaded. First, we create AppSettingsLoader.razor

@using AppSettingExample.Shared
@inject HttpClient http

@if (IsLoaded)
{
    @ChildContent
}


@code 
{
    [Parameter]
    public RenderFragment ChildContent { get; set; }

    public bool IsLoaded { get; set; }

    protected override async Task OnInitializedAsync()
    {
        await base.OnInitializedAsync();
        if (!IsLoaded)
        {
            var appSettings = await http.GetJsonAsync<ClientAppSettings>("api/ClientAppSettings");
            AppSettings.BaseApiUrl = appSettings.BaseApiUrl;
            IsLoaded = true;
        }
    }
}

Because we can’t (or I couldn’t) load the ClientAppSettings instance into the Dependency Injection to make it available throughout the application, I’m just putting the values in a static AppSettings class.

Now, in the MainLayout.razor we can wrap the @body with the AppSettingsLoader

<AppSettingsLoader>
@Body
</AppSettingsLoader>

And finally, from the Index.razor page we can reference the AppSettings.BaseApiUrl. To prove it out, I’ll just display it on the page.

@page "/"
<h1>Hello, world!</h1>

@AppSettings.BaseApiUrl

And now we can set any setting we like in the ClientAppSettings sections of the AppSettings.json and it will be treated just like a normal app setting, including being able to set the setting through Configuration section of an Azure App Service.

Visual Studio Tips - Code Definition Keyboard Shortcuts

Jeremy Hutchinson — Wed, 24 Apr 2019 00:00:00 UTC

Often when we’re coding, we need to take a look at the definition or sometimes the implementation of a method we’re calling. Visual Studio has a few great ways to speed these tasks.

Goto Definition

To see the definition of a variable, class, interface or method, you place your cursor on the thing you want to see the definition of, and either press F12 or right click and choose Goto Definition.

One catch with Goto Definition is that when you use it to go to a definition of a property or method, it goes it goes to the definition of the object as it is declared. That means that if you hit F12 on all of the SayHello() methods below you would go to IGreeter.SayHello for greeter1, SimpleGreeter.SayHello for greeter2 and greeter3 and WorldGreeter.SayHello() for greeter4.

            IGreeter greeter1 = new SimpleGreeter();
            Console.WriteLine(greeter1.SayHello());

            SimpleGreeter greeter2 = new SimpleGreeter();
            Console.WriteLine(greeter2.SayHello());

            SimpleGreeter greeter3 = new WorldGreeter();
            Console.WriteLine(greeter3.SayHello());

            WorldGreeter greeter4 = new WorldGreeter();
            Console.WriteLine(greeter4.SayHello());

Peek Definition

If you wanted to take a peek at the definition without navigating to its definition, you can use Alt+F12 or right click and choose Peek Definition. This brings up the definition in a little window within the code editor. You can still scroll through the code of the definition without losing your place in the code you are editing. Esc closes the Peek window.

Goto Implementation

If you want to view the implementation of a method or property rather than its definition you can press Ctrl+F12 or right click and choose Goto Implementation. If there is only one implementation for a method, Visual Studio takes you directly to the implementation. If there are multiple implementations, it brings up a window that lists the implementations. You can view the implementations by using your arrow keys or by clicking on them.

For the code above it would go directly to the implementation for greeter4.SayHello(), for all the others it would bring up the implementation selector window.

Find All References

Sometimes it’s helpful to see what other code is referencing a method or property. For that, you can use the official shortcut Ctrl+K+R, or the unlisted shortcut Shift+F12, or you can right click and choose Find All References. This brings up a window that lists all the references to that method. This displays the same list regardless of how the object is declared.

View Call Hierarchy

Sometimes it is handy to be able to see what code is calling a method or property, and what code led to that call. To see that you can right click on the method or property you’re interested in and choose ‘View Call Hierarchy’ or Ctrl+K, Ctrl+T. This brings up a tree view with the method or property you’re interested in and allows you to dig in until you get to the initial action that caused the method or property to be called. In the case below we can see that the SayHello() method was called by the Run() method which was called by the Main([string]). In the right pane, we can see the line and column that Run() is called from and double-clicking that takes us to that location.

Visual Studio Tips - Bulk Editing Shortcuts

Jeremy Hutchinson — Mon, 15 Apr 2019 00:00:00 UTC

One of the most tedious things we do as developers is making repetitive changes. Maybe we need to set a handful of properties on a single object, or perhaps we want to add a property to the instantiation of a bunch of test objects. Here are a few shortcuts to help you with that.

Multi-Caret Editing

Let’s start with adding a property to the instantiation of some test objects. This is often the perfect scenario for “muti-caret editing.” To start this you can do two things. The first is to position your caret where you’d like to start editing on the first line, then hold Shift+Alt and either use your arrows or the mouse to select a column or area. The beautiful thing about this method is it allows you to select a block of text to replace.

The drawback of using Shift+Alt is that the columns you want to edit must line up vertically. But frequently that isn’t the case, and that’s where Ctrl+Alt comes into play. With Ctrl+Alt you set the multiple carets by holding Ctrl+Alt and clicking where you want to edit. You can then insert text in all those places, even multiple times on the same line.

Duplicate Line

Those work great if the lines you want to edit already exist, or if you know how many lines you need to create at once. But I often find myself wanting to duplicate a line and make a few changes to it. For that, you can use the Ctrl+E, Ctrl+V keyboard shortcut which duplicates the line your cursor is on.

Clipboard Ring

Another feature I find very useful when I’m making repeated edits is the Clipboard Ring. When you hit Ctrl+Shift+V, it brings up your clipboard ring which includes the last nine things you’ve copied or cut (more recently used at the top). You can then select the item you want to paste by typing the number, using your arrow keys or clicking with your mouse.

This can be useful when you need to copy multiple things from one file to another. You no longer need to flip back and forth, just copy, copy, paste, paste.

Insert File as Text

This last feature I just stumbled upon while looking for something in the Edit menu. It’s not something I expect to use a lot, but it might be useful. In the edit menu is a command “Insert File as Text”, and the command does just what it says.

Visual Studio Tips - Test Explorer

Jeremy Hutchinson — Mon, 08 Apr 2019 00:00:00 UTC

The Test Explorer has a great ability to filter tests in a number of different ways so you don’t have to run your whole test suite when you’re just working on something that only affects a handful of tests.

First when running tests, remember the few handy keyboard shortcuts

Ctrl+R,T - Run all tests
Ctrl+R,Ctrl+T - Debug all tests
Ctrl+R,L - Re-run last test run
Ctrl+R,Ctrl+L - Debug last test run

The ability to re-run the last test run can be very handy if you don’t want to take the time to filter your test run down. You can right click and run the test or group of tests that makes sense, then use the keyboard shortcut re-run that set of tests until you’re ready to move on.

Group By

By default, the Test Explorer window uses the ‘Test Hierarchy’ view which displays tests based on Project, Namespace, Class, Test, TestCase. If you turn off the ‘Test Hierarchy’ view you have the option to change the grouping to one of the following views:

Class - Groups tests by Class, Test, TestCase. Though the namespace isn’t displayed classes with the same name in different namespaces are shown separately.
Duration - Groups tests into 3 buckets. Fast (<100ms), Medium, Slow (>1s)
Namespace - Grouped by Namespace, Class, Test, TestCase
Project - Grouped by Project, Test, TestCase (ignores Namespace)
Outcome - Groups tests by Passed, Failed and Not Run. This is handy when you’re trying to fix a handful of failing tests.
Trait - Groups tests by various traits about the tests. Tests can be listed in this multiple times and combined with filters this can be a very powerful view.

Traits

How you assign Traits for tests differs depending on what unit testing framework you choose. This example shows some basic traits from nUnit.

[Category("Integration_Tests")]
[Property("Priority", 2)]
public class BazTests
{
    [Test]
    public void BazTest1()
    {
        Thread.Sleep(200);
        Assert.Fail();
    }

    [Test]
    [Explicit]
    [Category("Slow_Tests")]
    [Category("Useless_Tests")]
    public void BazTest2()
    {
        Thread.Sleep(2000);
        Assert.Fail();
    }
}

I’ve assigned all of the tests in the TestClass to the ‘Integration_Tests’ category, and also labeled that as ‘Priority 2’. The BazTest2 test has been also marked as Explicit, and it has been assigned that test to both the ‘Slow_Tests’ and the ‘Useless_Tests’ category.

Now, when I view my test suite from the Test Explorer it looks like this

I can then apply a filter to that view to narrow it down. Let’s say I wanted to look at just ‘Integration_Tests’, I can add the Trait:"Integration_Tests" filter to the search area of the Test Explorer. That removes all the tests that don’t meet that criteria, which still leaves me with 2 tests, but it still shows the other Traits related to those tests. I could just right click on the ‘Slow_Tests’ node and choose ‘Run Selected Tests’ and I would just run the BazTest2.

Playlists

Playlists allow you to create a custom group of tests by whatever criteria you decide. Maybe you have a group of tests that you want to run whenever you’re working on a certain part of the code. You can add those tests to a playlist then select the playlist to filter your tests. You can also check in these playlists for others to use.

Run Tests After Build

Once you have your list of tests filtered just the way you want it, I recommend clicking the ‘Run Tests After Build’ button to ensure that your filtered list of tests runs after every build (tests marked Explicit will not run).

Depending on how many tests you have in your filtered list, their performance and how well isolated they are, you may also want to have them run in parallel.

Visual Studio Tips - Window Management

Jeremy Hutchinson — Thu, 04 Apr 2019 00:00:00 UTC

Everyone has their own favorite layout for the various tool windows in Visual Studio. But sometimes you want different Window layouts based on what you’re working on, or whether you have external screens attached to your laptop.

First the basics of tool windows.

You can click and hold any window by its header (or its tab if it is already docked) and drag it. While drag it you will see a bunch of little blue boxes indicating where it can docked, if you drop it on one of those it will dock, otherwise it will float and can even be moved to a second monitor.

If a window is docked, you can Pin a window with the Thumbtack icon to make it always visible, or if it’s already pinned you can Unpin it to make it Autohide.

Save Your Window Layouts

Once you have all your windows where you want them you can Save the layout by going to Window -> Save Window Layout. You’ll be prompted to name your layout. This saves which windows are open, where they are docked, whether they are pinned or autohidden, and their size.

Once you’ve save a layout or two, you can either go back to the Window menu, click Apply Window Layout and select your layout from the list. Or you can use the hot key combination for the layout (ie Ctrl+Shift+1 for layout 1)

The Catch

The one slightly unintuitive part of saving window layouts is that when you save a layout, that is for both the layout for editing and the layout for debugging which are often different. So to set a layout, you need to get all the windows where you want them in edit mode, then start a debug session to get all of those windows where you want them, then save the layout. Otherwise you’ll find yourself needing to switch layouts every time you go from editing to debugging and back.

Visual Studio Tips - Keyboard Shortcuts for Debugging

Jeremy Hutchinson — Wed, 03 Apr 2019 00:00:00 UTC

There are literally hundreds of keyboard shortcuts in Visual Studio, and few people have them all memorized, but it is definitely worthwhile to memorize at least a few. Here are some that are useful while you’re debugging.

F5 - Run - This both starts the debugging session and continues the debugging session if the session is paused.
F10 - Step Over - This runs just the next statement. If the next statement is a function call, it runs the whole function before pausing execution again (unless there is a breakpoint in the function).
F11 - Step Into - This runs just the next statement. If the next statement is a function call, it will bring you to that function and pause before the first statement in there is run.
Shift+F11 - Step Out - This runs until the code returns from the currently running function. It’s really handy when you are done debugging a function, but that function still has a lot of statements to execute.
Ctrl+F10 - Run to Cursor - This allows you to move the cursor to a line of code then run until the debugger gets there. This is handy if you want to skip over a block of code. You could also press F9 then F5 which would add a Breakpoint at your cursor, then run to it.
Ctrl+Shift+F10 - Set Next Statement - This sets the line your cursor is on as the next statement the debugger will run. Really handy if you missed something and want to backup and debug it again.
Alt+Num * - Show Next Statement - Sorry laptop users, this one only works with the * on the number pad. This one takes you to the next statement that will run. Really handy if you’ve been sifting through code and want to quickly return to your debugging without executing any statements.
Shift+F5 - Stop Debugging - Ends your debugging session.
Ctrl+Shift+F5 - Restart Debugging - Getting the message “Edits were made to the code which cannot be applied while debugging”? This will quickly restart the debug session and have you on your way.

All of these are of course available through the UI, but if you often find yourself looking for them in the command bar, or right clicking and trying to find them in the context menu, memorizing at least some of these shortcuts will keep you focused on the debugging.

Visual Studio Tips - Trace Points

Jeremy Hutchinson — Tue, 02 Apr 2019 00:00:00 UTC

Tracepoints are not a new feature, they’ve been in Visual Studio since 2005, but they are a new feature to me. I just stumbled on them while researching for this series of posts. Tracepoints allow you to turn a Breakpoint into what is essentially a call to Debug.WriteLine().

A Tracepoint is just a special kind of Breakpoint that allows you to log a message to the Output window and continue execution. This can be really helpful in situations where stopping at a breakpoint makes reproducing a bug difficult or impossible.

And since Tracepoints are just a kind of Breakpoint, you can also put conditions on them and manage them just like Breakpoints. To learn more about Breakpoints see this post.

To set a Tracepoint, you set a normal breakpoint, then go into the settings of that Breakpoint and check Actions. That will display a textbox for you to create your log message and another checkbox to specify whether execution should stop or continue.

Visual Studio Tips - Using Data Tips

Jeremy Hutchinson — Mon, 01 Apr 2019 00:00:00 UTC

Data tips, the Visual Studio feature that allows you to hover over a variable and see its value while debugging, can be super useful. Here are a few tricks that you may not know about them.

Have you ever been looking in the DataTips then need to look at the code behind them? Great news, you can. Just press and hold Ctrl key, the DataTips become transparent until you release the Ctrl key. This is particularly useful when you’ve drilled down a bit in the DataTip or you’re trying to compare

Another thing you can do is either pin the DataTips. This persists the DataTip so you can navigate to other code, restart debugging or even restart Visual Studio and still have the DataTip be there when you break in that block the next time. Once you’ve pinned a DataTip you can move the data tip around by clicking and dragging, you can remove it by clicking the x, or you can float the DataTip by clicking the pin icon. This allows you to view that DataTip while you scroll the code or view another file.

Once you’ve pinned a DataTip, you can add expressions to that DataTip by right-clicking on the DataTip and choosing “Add Expression”. This can let you pin something more useful than what might normally display for an object. In this case, the DebuggerDisplay shows LastName, FirstName, but we can add an expression to display the Person object as FirstName LastName. This is really handy for when you can’t change the DebuggerDisplay of an object.

The other interesting feature of DataTips is that you can add comments to them.

But what good are comments if you can’t share them? Well, you can export your DataTips to an XML file and either share them or check them in with your source. You could have a set of DataTips that you load up whenever you’re facing a common debugging scenario.

You might also notice there are options in there to “Clear All DataTips”, and “Clear All DataTips from [CurrentFileName]”.

Visual Studio Tips - Solution Explorer Search

Jeremy Hutchinson — Fri, 29 Mar 2019 00:00:00 UTC

Solution Explorer Search has been in Visual Studio for a while, but there are a few features that I think many developers overlook (myself included). Here are a few that you might have missed.

By default, the search will search Ctrl+; both the file names and the contents. This is what we want most of the time, but it is possible to search just the file names.

Some other filters you can apply to your search are Open Files Ctrl+[,O and Pending Changes Ctrl+[,P. These can be particularly useful when you’re working on a feature that requires changes across multiple files in different layers of your solution. In the gif below I show these filters being used via the UI.

Visual Studio Tips - Breakpoints

Jeremy Hutchinson — Thu, 28 Mar 2019 00:00:00 UTC

Most of us know about Breakpoints and how to use them, but there are a few under-utilized features of breakpoints that you should be aware of.

You can set a simple breakpoint in a number of ways

Move the cursor to the line you want to break on and hit the F9 key
Right click on the line of code
Clicking in the gutter

Once you have a breakpoint set you can do a few things with it. First, you can disable it, if you don’t need the breakpoint right now, but think you might come back to it.

You can also disable all breakpoints from Debug -> Disable all breakpoint. This is handy for when you need to run and get reset, then re-enable all breakpoints and start your debugging again.

You can also make the breakpoint conditional based on the value of a variable or any boolean expression (yes, you can use the No Side Effects formatter). This can be helpful if you want to break when the value of a variable is a certain value.

You can also make the breakpoint conditional base on the number of times a breakpoint is hit. For example, you might know that the first time a breakpoint is hit isn’t interesting to your debugging scenario but every time after that is interesting. You could set hit count > 1.

You can also filter your breakpoints to a single thread or to exclude a thread, either by name or id.

Visual Studio Tips - Source Map in the Scroll Bar

Jeremy Hutchinson — Wed, 27 Mar 2019 00:00:00 UTC

Do you find yourself scrolling up and down in a large file in Visual Studio? “Show Source Maps in Scroll Bar” gives you a 1000 foot view of your code and allows you to navigate with a simple click.

To turn this feature on go to Tool -> Options -> Text Editor -> Scroll Bars. In the Behavior section select “Use map mode for vertical scroll bar”. I also like to select “Show Preview Tooltip” as well. You can choose your own width, but I’ve been happy with “Medium”.

Once that’s done you can navigate your code like this

Note that both there are 3 artifacts on the Source Map.

A white bar that indicates where you are in the document
A white block on the left side of the source map to indicate a bookmark
A red block on the left side of the source map to indicate a breakpoint

Visual Studio Tips - Evaluate a Function Without Side Effects

Jeremy Hutchinson — Tue, 26 Mar 2019 00:00:00 UTC

Ever been debugging and wanted to know what the result a function call would but calling it would change the state in a way that would make continuing difficult or impossible? Well, you can evaluate it and specify that it does not have any side effects.

Take this simple class that tracks a count and has a method for incrementing that count.

class Foo
{
    public int Count { get; private set; } = 0;

    public int AddOne()
    {
        Count++;
        return Count;
    }
}

If we want to see what the result of the AddOne() method would be, but we don’t want to actually increment the count because we can’t set it back we can use the nse (no side effects) format specifier in both the watch window and the Immediate Window.

foo.AddOne(), nse

Visual Studio Tips - View Uncaptured Exception

Jeremy Hutchinson — Mon, 25 Mar 2019 00:00:00 UTC

Ever have code where you catch an exception because to handle it, but you don’t need to use the exception itself? Maybe just knowing the exception type is enough for you. But then you sometimes want to see it while debugging?

Previously I would just capture the exception and just live with the warning about an unused variable, but now I do this.

First, what do I mean when I say caught but not captured? In the code below I have caught the InvalidOperationException thrown by trying to get the first item from an empty collection. But I haven’t captured the exception in a variable.

var foo = new List<string>();

string bar;
try
{
    bar = foo.First();
}
catch (InvalidOperationException)
{
    //Do something like logging or retry
    bar = null;
}

Without having to change the code at all we can view the exception by viewing the contents of the $exception pseudovariable which holds the value of the most recent exception. You can either get the value by adding it to your watch list or by evaluating it in the immediate window.

Visual Studio Tips - DebuggerDisplay

Jeremy Hutchinson — Fri, 22 Mar 2019 00:00:00 UTC

When you look at an object in the Watch window what you see is whatever comes out of the ToString() method. But what if you could control what was displayed so that you could see some meaningful value? Well, you can.

If we have a Person class define like this

namespace VSTips.DebuggerDisplay
{
    class Person
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }
}

If we create an instance and look at it in the watch window all we see is {VSTips.DebuggerDisplay.Person}. We can of course drill in to see the individual properties, and that isn’t so bad when you’re looking at a single object, but when you look at a List<Person> and see this, you know you’re going to spend a lot of time clicking to find the object you’re looking for.

If we go back to the definition of the Person class and add an attribute we can make the watch window display whatever we want. In this case, we’ll display the last name and the first 5 characters of the first name (taking the first 5 just to show the flexability).

using System.Diagnostics;

namespace VSTips.DebuggerDisplay
{
   [DebuggerDisplay("{LastName,nq}, {FirstName.Length >= 5 ? FirstName.Substring(0, 5) : FirstName,nq}")]
    class Person
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }
}

When you look at the watch list with this Debugger Display what you see is much more helpful.

Random Value Per Row in SQL

Jeremy Hutchinson — Tue, 08 Jan 2019 00:00:00 UTC

Occasionally you need to update a table with a random value per row. And thanks to some optimizations SQL Server does, it’s not exactly straight forward.

If you just try to update with a random value like this, every row ends up with the same ‘random’ value.

update MyTable
   set SomeValue = rand()   

This is because SQL Server only runs the rand() once because it doesn’t depend on any value from the row. My next thought was to see the rand() with a value from each row.

update MyTable
   set SomeValue = rand(Id) --Where Id is in Int

This wasn’t as random as I had hoped. Since my Id column was an identity column the ‘random’ numbers were almost sequential as well. For example, I got the following ‘random’ numbers for the following Id values:

Id	Rand(Id)
101	0.715436657367485
102	0.715455290338744
103	0.715473923310002
104	0.715473923310002

So, I needed to come up with a way to get the seed value to vary for each row. So I decided to get the MD5 hash of the Id column.

update MyTable
   set SomeValue = rand(HASHBYTES('md5', convert(varchar, Id))) 

That results in these values:

Id	rand(HASHBYTES(‘md5’, convert(varchar, Id)))
101	0.954016112182829
102	0.249482833129777
103	0.863832691946289
104	0.751055796147016

And that was random enough for my needs.

Data Driven Layout in Server-side Blazor

Jeremy Hutchinson — Mon, 24 Sep 2018 00:00:00 UTC

One thing I stumbled on with Blazor was how to create a layout that changed based on the data on the page. For example, you may want to include bread crumbs in the header of your page. You could get the URL and try to parse out where in the application from your MainLayout, and then figure out what you need to figure out to create your breadcrumbs. But ideally you’d have each page figure out it’s own breadcrumbs and pass that data to the header.

In Razor Pages you could do this with a an RenderSection in your layout, then defining the Section in your page, which could be a component that you pass some values to. But, RenderSection hasn’t been implemented in Blazor (I’m not sure if it’s coming or not). Here’s two alternative techniques.

First thing we’ll need to do is open the _ViewImports.cshtml and comment out or delete the @layout MainLayout that defines the layout for all the pages in the folder.

Then we’ll create an AppState class to hold the data we want to pass between the page and the layout. For now we’ll just capture the page name. This piece will be common between both techniques.

    public class AppState
    {
        public string CurrentPageName { get; set; }
    }

The two techniques also share the NavMenu which takes AppState and uses that to display the CurrentPageName

@if (!string.IsNullOrEmpty(appState.CurrentPageName))
{
    <div class=@(collapseNavMenu ? "collapse" : null) onclick=@ToggleNavMenu>
        <ul class="nav flex-column">
            <li class="nav-item px-3" style="color:white;">
                Current Page: @appState.CurrentPageName
            </li>
        </ul>
    </div>
}

@functions {
    [Parameter] protected AppState appState { get; set; }

    bool collapseNavMenu = true;

    void ToggleNavMenu()
    {
        collapseNavMenu = !collapseNavMenu;
    }
}

Layout Component

For the Layout Component technique we’ll create a Blazor Component called MainLayout2 that takes it’s child content from the calling markup. It has two key parameters, AppState and ChildContent. It just passes the AppState along to the NavMenu component.

@inherits BlazorLayoutComponent

<div class="sidebar">
    <NavMenu appState="@appState" />
</div>

<div class="main">
    <div class="top-row px-4">
        <a href="https://blazor.net" target="_blank" class="ml-md-auto">About</a>
    </div>

    <div class="content px-4">
        @ChildContent
    </div>
</div>

@functions
{
    [Parameter] protected AppState appState { get; set; }
    [Parameter] protected RenderFragment ChildContent { get; set; }
}

Not that the RenderFragment must be named ChildContent in order for Blazor to get the content correctly later.

Then from the page we wrap the content of the page in a <MainLayout> tag and from the OnInit set the AppState.CurrentPageName to the name of the page’

@page "/counter"
@inherits BlazorComponent
<MainLayout2 AppState="@appState">
    <h1>Counter</h1>

    <p>Current count: @currentCount</p>

    <button class="btn btn-primary" onclick="@IncrementCount">Click me</button>    
</MainLayout2>
@functions {
    int currentCount = 0;

    void IncrementCount()
    {
        currentCount++;
    }

    protected AppState appState { get; set; } = new AppState();

    protected override void OnInit()
    {
        appState.CurrentPageName = "Counter";
        base.OnInit();
    }
}

Dependency Injection

Another possibility is to use Dependency Injection to inject a single instance of the AppState into both the page and the layout, then updates to that object in the page will be visible to the layout.

First we need register the AppState class in the StartUp.ConfigureServices. We need to register this as a Scoped lifetime. See my post on Blazor DI Lifetimes for a better understanding of the various lifetimes in Blazor.

services.AddScoped<AppState>();

Then in the MainLayout.cshtml we inject the AppState and pass that to the NavMenu

@inherits BlazorLayoutComponent
@inject AppState appState

<div class="sidebar">
    <NavMenu appState="@appState" />
</div>

<div class="main">
    <div class="top-row px-4">
        <a href="https://blazor.net" target="_blank" class="ml-md-auto">About</a>
    </div>

    <div class="content px-4">
        @Body
    </div>
</div>

We also need to inject the AppState into the page, and set the CurrentPageName in the OnInit method. In this case since we’ve removed the @layout directive from the _ViewImports.cshtml we need specify the layout in the page.

@page "/counter2"
@inject AppState appState
@layout MainLayout

<h1>Counter2</h1>

<p>Current count: @currentCount</p>

<button class="btn btn-primary" onclick="@IncrementCount">Click me</button>
@functions {
    int currentCount = 0;

    void IncrementCount()
    {
        currentCount++;
    }
    protected override void OnInit()
    {
        appState.CurrentPageName = "Counter";
        base.OnInit();
    }
}

Which is better

The biggest difference is the lifetime of the AppState. With the Layout Component technique you create a new instance of the AppState each time the page loads. With the Dependency Injection technique you keep the same AppState until the user refreshes.

This is a double edged sword. On the one hand, if you need to retrieve some data from the database or an API, you have built in caching. On the other hand you need to keep in mind that data might be stale.

For an example of this you can download and run the complete project, navigate to /Counter2, then to FetchData. You’ll see that the current page is still listed as Counter2 because the line to set the CurrentPageName is commented out.

The Layout Component technique on requires you to wrap your content in the layout tag. Not only is this extra boilerplate in every page, it’s may make it more difficult to do things like nested layouts.

Full source https://github.com/hutchcodes/Blazor.DataDrivenLayout

Dependency Injection Lifetimes in Blazor

Jeremy Hutchinson — Mon, 17 Sep 2018 00:00:00 UTC

I’ve been playing with Server-side Blazor for a few days and I’ve been really impressed. I can see that this will be an immensely powerful technology and I hope to make it my main web platform going forward. But it’s model does change some things. Since you’re running the app on the server and just using SignalR to update the browser’s UI it changes the lifetime of Scoped objects in Asp.Net’s dependency injection.

For a great analysis of DI scopes and lifetimes checkout Michal Dudak’s post. I based my testing of scopes off of his simple scenario to see how the scopes differed in Server-side Blazor.

First I created 3 simple services

public class SingletonService
{
    public int Counter;
}
 
public class ScopedService
{
    public int Counter;
}
 
public class TransientService
{
    public int Counter;
}

Then I registered those services with Asp.Net in startup.cs.

public void ConfigureServices(IServiceCollection services)
{
    // Since Blazor is running on the server, we can use an application service
    // to read the forecast data.
    services.AddSingleton<WeatherForecastService>();

    services.AddSingleton<SingletonService>();
    services.AddScoped<ScopedService>();
    services.AddTransient<TransientService>();
}

Then in the Configure method of startup.cs I requested an instance of the services and incremented the counters.

public void Configure(IBlazorApplicationBuilder app)
{
    app.AddComponent<App>("app");

    app.Services.GetService<SingletonService>().Counter++;
    app.Services.GetService<ScopedService>().Counter++;
    app.Services.GetService<TransientService>().Counter++;
}

Then I added a new page that gets those services injected, increments the counters and displays the results.

@page "/dilifetimes"
@using Blazor.DI.Lifetimes.App.Services
@inject SingletonService singletonService
@inject ScopedService scopedService
@inject TransientService transientService

<table class="table">
    <thead>
        <tr>
            <td>Lifetime Type</td>
            <td>Count</td>
        </tr>
    </thead>
    <tbody>
        <tr>
            <td>Singleton</td>
            <td>@singletonService.Counter</td>
        </tr>
        <tr>
            <td>Scoped</td>
            <td>@scopedService.Counter</td>
        </tr>
        <tr>
            <td>Transient</td>
            <td>@transientService.Counter</td>
        </tr>
    </tbody>
</table>

@functions
{
    protected override void OnInit()
    {
        singletonService.Counter++;
        scopedService.Counter++;
        transientService.Counter++;

        base.OnInit();
    }
}

As you would expect the values of counters are:

Singleton: 2
Scoped: 2
Transient: 1

And if you refresh, the values match what you see in a normal Asp.Net application

Singleton: 4
Scoped: 2
Transient: 1

But if you then navigate to a different page, then back to the DILifetimes page you get an odd result (literally);

Singleton: 5
Scoped: 3
Transient: 1

Transient works just as we’d expect. Every time we request an instance of that service we get a new instance. The instance that is incremented in the Configure method is different from the instance we get injected in the DILifetimes page.

And when we refresh the page both Singleton and Scoped work as we’d expect. The singleton service is the same instance that has already been incremented twice when we loaded the page. It gets incremented again in Configure and again in DILifetimes. We get a new Scoped service in the Configure method and increment it a second time in DILifetimes.

The odd thing happens. We navigate away from the page and back, and we only increment Singleton and Scoped once, from the DILifetimes page. This is because we haven’t actually done a full web request when we navigated. We actually sent a message through SignalR to tell Server-side Blazor that we navigated. Blazor then did the navigation at the server and sent back the changes to the DOM which are then updated on the screen. The Configure method is never run.

The message here is that Scoped services have a much longer lifetime in Server-side Blazor than they did in a traditional Asp.Net application. This can be good or bad, but it’s definitely good to be aware of.

Full source available https://github.com/hutchcodes/Blazor.DI.Lifetimes

Removing Items From a List

Jeremy Hutchinson — Wed, 08 Aug 2018 00:00:00 UTC

It’s not at all uncommon to need to iterate through a List to remove an item. And about half the time when I do so I get a “Collection was modified; enumeration operation may not execute.” exception the first time I run the code. Then I do something fancy like use a for loop to iterate through the list backward and remove the items from the list. Something like this:

var foo = new List<string>();
foo.Add("Fizz");
foo.Add("Zebra");
foo.Add("Buzz");
foo.Add("Bazz");

for(var i=foo.Count()-1; i>=0; i--)
{
    if (foo[i].Equals("Zebra")){
        foo.Remove(foo[i]);
    }
}

But somehow after an embarrassingly long time of doing that I’ve found a much simpler way, that I suspect everyone else has known about for a while, but just in case, here it is.

Just take your list and cal ToList(), iterate through the new list and remove items from the original.

foreach (var s in foo.ToList())
{
    if (s.Equals("Zebra")){
        foo.Remove(s);
    }
}

Of course, this technique may have some memory or performance consequences. If I run into a case where that becomes a problem I can go back and optimize then. From here forward I’ll optimize for readability.

Working Remote

Jeremy Hutchinson — Thu, 07 Jun 2018 00:00:00 UTC

One of my coworkers will be moving and switching to working remotely. He asked me to share my thoughts about working remote and it turns out I have a lot. Hopefully, they are worth sharing.

I’ve been remote for 4 years now as an employee, and also worked remotely for about 7 years while as an independent consultant. The consulting was more solo work and less teamwork and was much more isolating, but it did help me form some boundaries around working from home. At this point, I hope never to work in an office again. Here’s what I think are the keys to being happy working from home:

Boundaries

Have a separate office space. This way you “go to work” by walking through a door, and you “come home” later. That’s not to say that you can’t “leave work” to do something at home for 5-10 minutes or a few hours (which I definitely do), just that you want to make sure you’re not mixing home and work because work will eventually start intruding on home life.
Keep “regular hours” and don’t worry about being unavailable when you’re not “at work”. I generally try to work from 7:30-3:30 or 4 (depending on school drop-offs) every day. There will still be some flexibility, but again the worry is that work will start to creep into home life if you don’t.
Consider adding some “commute time” to your day. When you work in an office, you have some time on your commute where you transition from home to work and back again. It can sometimes be difficult to make that same transition over just a dozen steps. I just need a few deep breaths, but I’ve heard of people walking around their house or around the block.

Communication

Ask yourself if you’re using the right communication tool. Don’t just rely on chat for all communication. Chat is a great communication tool, but you lose tone of voice and body language. If you’re in a long complicated chat, pick up the phone or consider a screen share or video chat.
Get comfortable with your video camera and encourage your coworkers to do the same. Try to have at least few video chats a week with your people from your team. Being able to see someone’s face rather than them just being a disembodied voice helps create connections.
Buy a decent USB camera and put it at the top of your main monitor. Then when a video chat starts put the video screen centered right below the camera. Otherwise, you’re sharing the side of your head or an up-the-nose shot (thanks for putting the camera at the bottom of the screen Dell). Remember that “eye contact” is made by looking at the camera, not at people’s eyes.

Socializing

Embrace on-site trips. A few days face to face with your co-workers goes a long way towards building the relationships needed to work effectively while remote.
Figure out how to get your socialization outside of work. You’re not going to have as many informal chats in the kitchen and you’re not going to go out to lunch with coworkers. You need to find a way to fill this gap or it will slowly wear you down.

Enjoy

Take full advantage of being remote. Take a walk or a nap mid-day, spend a bit of time with the kids when they get home from school, start cooking dinner in the middle of the afternoon. Take a conference call on the couch or out on the patio.

These are the things that I feel have made working remotely work well for me. Others may find something here completely unimportant to them or may see something I completely missed, but it’s a place to start.

Networking Online

Jeremy Hutchinson — Wed, 27 Dec 2017 00:00:00 UTC

Which online social network is the best when looking for a new job? If you had asked me 2 weeks ago I would have told you it was LinkedIn, but it turns out LinkedIn is a distant second.

I have always maintained a bit of separation in my social networks.

Facebook is for friends and family and a few people from the “work world” that I trust won’t hold my occasional political rant against me. I almost never post anything work related there.

LinkedIn is primarily just work-related folks. I post almost exclusively work related stuff here. Stuff I wouldn’t mind prospective employers seeing.

Twitter is where I let the two worlds meet. I follow a broad range of people and I tweet personal, political, humorous and work stuff.

My expectation has always been that if I needed to find a job, my LinkedIn network would be the most valuable. And when it recently became apparent that my current employer wasn’t going to work out long-term I posted the following on LinkedIn:

I also posted this similar message on Twitter:

Anyone in need of of a Senior/Lead C# Developer with a load of experience in both Azure and AWS? I'm primarily looking for remote. A retweet might get the right eyes on this.
— Jeremy Hutchinson (@hutchcodes) December 7, 2017

The response from LinkedIn was OK, I guess. few people liked it, a few of my former coworkers suggested positions at their current companies, and a recruiter contacted me, but never responded after I said I was only willing to make the 2hr drive to the office a few times a month.

The response on Twitter was overwhelming. A few people liked it, a bunch of people re-tweeted it, and total strangers contacted me about open positions that allowed remote. Most of those positions were at the companies they worked, but a few people pointed me to positions at companies they didn’t work for but knew were hiring remote developers.

Twitter resulted in interviews with 3 companies that I’d be interested in working for.

	LinkedIn	Twitter
Followers	231	425
Views	877	16.3k
Likes	9	22
Comments	2	6
Shares	0	99
Job Openings	3	15
Interesting to Me	0	5
Interviews	0	3

Why Twitter?

I’m just guessing here, but I think it comes down to two things:

Twitter is more active. I check LinkedIn just about once a week. And I rarely if ever scroll through the feed there.
Part of the Twitter experience is re-tweeting. Sharing posts is an option in LinkedIn, but it’s not used as often.

Takeaways

Build your Twitter network as best as you can. I’ve put work into providing some good content over the years to get to the number of followers I have.
Return the favor. When you see someone post that they are looking for work, retweet that. Same for companies looking to fill positions.
Nurture the rest of your network too. Twitter was far more effective for me, but I did get some leads from LinkedIn, those came from people that aren’t active on Twitter as far as I know. Those positions weren’t interesting this time, but you never know what’s going to come up.

Simple Deploy to Azure from Command Line

Jeremy Hutchinson — Fri, 01 Sep 2017 00:00:00 UTC

I’m currently working on moving our product from AWS to Azure and as part of the planning for that move, one of the problems I needed to solve was deployment. Our current deployments are handled by an automated build on Bamboo, but Bamboo doesn’t have a “Deploy to Azure” task. I needed to do the deploy from the command line (CMD or Powershell), and I wanted to avoid including publish profiles in the projects.

The first part, running from the command line was easy to find through with a Google search. You can just tell MSBuild to publish to Azure

msbuild MyWeb\MyWeb.csproj /t:TransformWebConfig;Publish /p:TargetProfile=ProdMyWebApp /p:Configuration=AzDev

But the catch is that you can’t do it without a publish profile as part of your project or at least I wasn’t able to make it work.

Instead of trying to do it with just MSBuild I used MSBuild to build a deployment package.

MSBuild MyWeb\MyWeb.csproj 
	/target:TransformWebConfig;Package 
	/p:Configuration=Prod;PackageLocation="Deployment\Prod.zip"

That transforms the web.config and creates a .cmd executable that we can call and tell to publish to Azure or IIS is WebDeploy is enabled.

Deployment\Prod.Deploy.cmd 
	/M:https://mywebapp.scm.azurewebsites.net:443/MSDeploy.axd 
	/a:basic 
	/U:$mywebapp 
	/P:[userPWD from your publish profile] 
	/Y

You do still need to download the publish profile from the Azure portal and open it in a text editor to pull out the publishUrl, userName and userPWD. The /Y means that it will go through with the deploy. You can also use /T to do a ‘What If’.

With these commands, I was able to automatically deploy our web app to Azure during our build process. And since I didn’t need to store the publish profile in the .csproj file, I don’t need to worry about someone deploying something from their machine without checking the code into source control.

Azure SQL vs AWS RDS Performance and Cost

Jeremy Hutchinson — Fri, 11 Aug 2017 00:00:00 UTC

I’ve been doing a series of blog posts comparing Azure and AWS services that I’ve used in production. This post is before production usage, but I’ve been researching and experimenting in preparation for proposing moving our databases to Azure and wanted to share my results so far.

Before I could propose this move I needed to understand the cost differences. To do that I needed to know which level of Azure SQL was equivalent to our m1.medium instance at AWS.

tl;dr

An AzureSQL Standard Tier S3 database performs is about 7% faster than a SQL Server SE 2008 R2 database running on an m1.medium instance of AWS RDS. Price comparison are hard because AWS RDS has a sea of options to choose from, but if you meet the requirements for SQL Server Web licensing then pricing is similar.

Performance

Performance in Azure is measured in DTUs (Database Transaction Units), a 100DTU database is twice as powerful as a 50DTU database and ten times as powerful as a 10DTU database.

At AWS you are purchasing an EC2 instance with SQL Server installed. They provide some guidance about how various instance will perform via their ECU ratings (EC2 Compute Unit), but it’s pretty coarse. An m1.Large is rated at 2ECU, and an m1.medium is 1ECU, but an m1.small is also rated 1ECU and is ~half as fast as the m1.medium, so it’s not a great comparison.

Since AWS and Azure don’t use the same measure for performance I did some benchmarking with TPCCBench. This tool runs an industry standard workload against a database. I ran it without the “thinking time” that the official TPC-C benchmarks would normally run with, but it with the same settings on both clouds.

On Azure I benchmarked a ton of different performance levels. All the way from Basic(5DTUs $5/month) up to a the Premium P15(400DTUs $16,000/month). As advertised, the performance at different levels went up in lockstep with the DTUs. A 100DTUs is ~10 times as fast as 10DTUs. When I got up to the Premium tiers, the load test utility couldn’t max out the instances. So at 250DTUs I was only able to use ~85% of the DTUs and with the P15 4000DTU instance I was only able to ~7% of the DTUs.

On AWS there you can choose from Express, Standard, Web and Enterprise licensing for SQL Server. These all have different costs, but should perform the same for the loads we’re looking at (look for someone to correct me in the comments). You can also choose between versions from 2008 R2 up to 2016, but once you get to 2016 you start to be limited in which EC2 instances you can choose.

I only benchmarked m1.small and m1.medium instance running SQL Server SE 2008 R2 on AWS because that’s all I had standing up at the time, and though I wouldn’t mind looking at the performance of some other instance sizes and SQL versions, I didn’t have time/money to go through the setup and config.

Cloud	Tier/Pricing Level	Orders/min
AWS	m1.small	2875
AWS	m1.medium	5690
Azure	Standard S3 (100 DTUs)	6103
Azure	Standard S2 (50 DTUs)	3051

Our production database runs on SQL Server SE 2008 R2 on an m1.medium instance, that load can easily be handled by an AzureSQL Standard Tier database with 100DTUs (either an S3 or as part of an Elastic Database Pool). That answers my first question.

Costs

Both licensing and instance size play into pricing on AWS. We are running SQL Server SE which costs $575/month for an m1.medium. If we ran SQL Server Web instead that would cost $195/month. If we used SQL Server Web on an m3.medium we would it would cost $150/month.

There are two pricing models in Azure. One is a Single Database pricing, the other is Elastic Database. With Elastic Database pricing the DTUs can be shared between multiple databases. This is similar to having multiple databases on one instance in AWS.

Cloud	Tier/Pricing Level	$/month	Notes
AWS	m1.small SQL Server Express	67	Our dev/test environment
AWS	m1.medium SQL Server SE	575	Our prod environment
AWS	m4.medium SQL Server Web	196	What we should be running our prod environment on
AWS	m4.large SQL Server Web	229	What we’d need to run our prod environment to use SQL Server 2016
Azure	Standard S2 (50 DTUs)	75
Azure	Standard S3 (100 DTUs)	150
Azure	Elastic (50 DTUs)	112
Azure	Elastic (100 DTUs)	225

As you can see the cost of AWS RDS varies greatly based on the licensing. If you’re running a publicly available website with a single database the cost is the same at both AWS and Azure. If your DB is for an internal application Azure is much cheaper. If you have multiple databases AWS might be cheaper, would be cheaper than the same power in Azure Elastic DB, but if you can split those database into two S2s or 10 S0s the cost is the same.

I’m not sure how we’ll manage our database in Azure. We may be able to run our dev\test database on the Basic tier (5DTU $5/month) or the Standard S0 tier (10DTU $15/month), or maybe it would make more sense to put them all in a 50DTU elastic pool ($112/month). For production we’ll probably start out with a Standard S3 for our main DB and a Standard S0 or S1 for our auditing DB. Then depending on the loads scale them back or possibly put them in an Elastic Pool together.

Conclusion

The people I spoke with who dodged the question and told me I needed to do my own testing were right. In the end there are too many variables on the AWS side to make a comparison. If you’re considering moving from one cloud to the other you’re going to have to get a benchmark tool and benchmark where you are coming from and where you think you might end up. I’m thinking of a follow up post to cover the actual steps I took in benchmarking.

This ain’t science

I can see that I’m not comparing apples and oranges on a few levels here. AzureSQL isn’t running SQL Server SE 2008R2, it’s running something closer to but not exactly SQL Server 2016. Maybe upgrading RDS to SQL Server 2014 would have provided better results. I also compared SQL Server Express on an m1.small to SQL Server SE on the m1.medium again not ideal.

In the end I just compared what I was currently using in AWS to see where it would fit in Azure.

Azure Blobs vs AWS S3

Jeremy Hutchinson — Tue, 28 Mar 2017 00:00:00 UTC

Part of my ongoing series comparing AWS and Azure for the services where I’ve used both in production. In this post I’ll be looking at the differences between Azure Blob Storage and Amazon S3 for storing and retrieving files.

tl;dr

Azure’s logical structure allows you to manage multiple containers at the same time.
AWS allows default documents and with that you can host a static site for pennies per month in S3.
Azure Blob can integrate Azure Search to allow searching the content of some documents

Management

In Azure Blob you have a Storage Account, within that storage account you can store Blobs, Files (think shared drive), Tables and Queues. Within the Blobs you have logical groupings called Containers. Containers are roughly equivalent to AWS S3 Buckets.

In both AWS and Azure you can exposes these Containers\Buckets publicly or require a key to access them. The urls look like this:

s3.amazonaws.com/[BucketName]/[FileName]

[StorageAccount].blob.core.windows.net/[Container]/[FileName]

Notice that StorageAccount becomes the sub-domain while all buckets are under the same S3 domain. This means that bucket names must be unique in AWS, while in Azure it is the Storage Account Name that must be unique.

This means with Azure you can create dev/test/prod Storage Accounts and keep the Container names consistent. So if you have multiple buckets that is less you need to manage when switching environments.

AWS S3 manages everything at the Bucket level. So if you have 3 buckets that all have the same access rules, you need to manage those rules 3 times. In Azure Blob you could put all those Containers in the same Storage Account, and manage them once. Multiply those 3 Buckets by 3 environments (dev/test/prod) and you’re starting to save quite a bit of time managing permissions with Azure Blob.

Uploading/Downloading Documents

In previous comparisons I’ve gotten into the differences in working with the services through the SDKs. In this case they are both very similar, and straight forward. Azure does require an extra step because you need to get a reference to the Storage Account before getting the reference to the Container, but it’s a single line of code.

Static Website Hosting

AWS S3 lets you host a static website in an S3 Bucket. To do this you set a default document, and if a request is made to the root of the bucket or to a “folder” it will try to return the default document.

This is something that Azure does not have. It was request 3 years ago and they now have it on their backlog. You can vote it up or check the status here.

Document Searching

Azure Blob Storage can be integrated with Azure Search allowing you to search the contents of stored documents including PDF, Word, PowerPoint and Excel documents. Doing this in AWS required a 3rd party services that cost $36k for the first year. This feature was the driving force in our move from AWS to Azure.

The documentation for Searching Azure Blob Storage is execellent.

Summary

AWS S3’s main advantage is that you can host a static site very cheaply, but that advantage looks like it is going to have a short shelf life.

If hosting a static site isn’t your goal Azure Blob Storage’s streamlining of management and it’s ability to search the contents of it’s documents are big advantages.

Azure Search for Jekyll

Jeremy Hutchinson — Mon, 05 Dec 2016 00:00:00 UTC

I added Azure Search to my static site built with Jekyll through the use of Azure Functions. Best part, it’s free*.

This example is for Jekyll, it will work with any static site. The only thing Jekyll specific is the JSON representation of the site, and any static site generator should be able to build that file. I’ve used (Pretzel and PieCrust as well, they are both nice tools, but hosting on GitHub pages has it’s advantages).

Creating a JSON of All Posts and Pages

The first thing I did was create a page in Jekyll to produce a JSON representation of all the Posts and Pages from my site. I added a new piece of meta-data to the front matter to indicate whether each page should be indexed for search. This way I can be sure that pages like my RSS feed, SiteMap and my search.json don’t get indexed.

---
layout: nil
includeInSearch: false
---
{% assign pages = site.pages | where:"includeInSearch", "true" %}
[
	{% for p in site.posts %}
	{
	"type": "post",
	"title": "{{ p.title }}",
	"publishDate": {{ p.date | jsonify }},
	"categories": [{% for cat in p.categories %}"{{ cat }}"{% unless forloop.last %},{% endunless %}{% endfor %}],
	"tags": [{% for tag in p.tags %}"{{ tag }}"{% unless forloop.last %},{% endunless %}{% endfor %}],
	"url": "{{ p.url }}",
	"content":{{ p.content | strip_html | json_escape | jsonify }},
	"excerpt": {{ p.excerpt | json_escape | jsonify | remove: '\n' }}
	}{% unless forloop.last %},{% endunless %}
	{% endfor %}

	{% for p in pages %},
	{
	"type": "page",
	"title": "{{ p.title }}",
	"categories": [{% for cat in p.categories %}"{{ cat }}"{% unless forloop.last %},{% endunless %}{% endfor %}],	
	"tags": [{% for tag in p.tags %}"{{ tag }}"{% unless forloop.last %},{% endunless %}{% endfor %}],
	"url": "{{ p.url }}",
	"content":{{ p.content | strip_html | json_escape | jsonify}},
	"excerpt": {{ p.excerpt | rstrip | json_escape | jsonify }},
	"description": {{ p.description | json_escape | jsonify }}
    }
    {% endfor %}
]

That’s simple enough. I had actually created that over a year ago when I first started to think about using Azure Search. I abandoned that attempt partly because it was going to be a manual process and I was worried I might forget the step to populate the index.

You can see the resulting search.json here

Function Triggered by a GitHub Webhook

The next thing I needed to do was get that into Azure Search in some automated fasion. For this I used an Azure Function with GitHub Webhook for a trigger. I’m going to assume you’ll be able to figure out how to setup a Function App and create the GitHub Webhook function from the Templates available.

The new function should look something like this:

Note that the GitHub Secret that is listed is action the _master admin key, and what you really need is the default function key (more info). Also, that Function App will be gone before I post this, so don’t worry about me sharing that key :)

Setting Up the GitHub Webhook

Next step is to go over to GitHub and create the WebHook:

Then scroll down a bit more and choose Let me select individual events That opens up of the list of events that will trigger the WebHook. Uncheck Push and check Page Build. That will trigger the WebHook to index the blog whenever the Jekyll site gets built. For debug purposes I also put a check in Watch. That way when I wanted to test everything I could just UnStar/Star my repo.

At this point we can test everything to ensure that the Webhook is working properly and our function is running. Once you confirm that is working you it’s time use the function to populate our index.

Loading the JSON into Azure Search

First thing we need to do is bring in a reference to the Azure Search SDK. To do this you need to create a project.json file in the BlogIndexer folder.

{
  "frameworks": {
    "net46":{
      "dependencies": {
        "Microsoft.Azure.Search": "1.1.3"
      }
    }
   }
} 

After that it’s just a matter of creating and populating the index.

#r "Newtonsoft.Json"

using System.Net;
using Newtonsoft.Json;
using Microsoft.Azure.Search;
using Microsoft.Azure.Search.Models;

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, TraceWriter log)
{
    WebClient client = new WebClient();
    client.Encoding = System.Text.Encoding.UTF8;
    string value = client.DownloadString("https://hutchcodes.net/search.json");
    var searchTopics = JsonConvert.DeserializeObject<List<Page>>(value);

    var indexClient = RecreateIndex();

    var batch = IndexBatch.Upload(searchTopics);
    indexClient.Documents.Index(batch);    
}

private static SearchIndexClient RecreateIndex()
{
    var queryApiKey = "[Your API Key]";
    var searchServiceName = "[You Search Service Name]";
    var searchIndexName = "[Your Index Name]";

    var searchServiceClient = new SearchServiceClient(searchServiceName, new SearchCredentials(queryApiKey));

    if (searchServiceClient.Indexes.Exists(searchIndexName))
    {
        searchServiceClient.Indexes.Delete(searchIndexName);
    }

    var definition = new Index()
    {
        Name = searchIndexName,
        Fields = new[]
        {
            new Field("Id", DataType.String) { IsFilterable = true, IsKey = true },
            new Field("Url", DataType.String) { IsRetrievable = true },
            new Field("Type", DataType.String) { IsFilterable = true, IsRetrievable = true, IsFacetable = true },
            new Field("Title", DataType.String) { IsSearchable = true, IsRetrievable = true, Analyzer = AnalyzerName.EnMicrosoft },
            new Field("Categories", DataType.Collection(DataType.String)) { IsFilterable = true, IsRetrievable = true, IsFacetable = true },
            new Field("Tags", DataType.Collection(DataType.String)) { IsFilterable = true, IsRetrievable = true, IsFacetable = true },
            new Field("Content", DataType.String) { IsSearchable = true, Analyzer = AnalyzerName.EnMicrosoft },
            new Field("Excerpt", DataType.String) { IsSearchable = true, IsRetrievable = true, Analyzer = AnalyzerName.EnMicrosoft },
            new Field("PublishDate", DataType.String) { IsRetrievable = true }
        }
    };
    searchServiceClient.Indexes.Create(definition);
    var indexClient = searchServiceClient.Indexes.GetClient(searchIndexName);
    return indexClient;
}

public class Page
{
    public string Id { get { return Url.GetHashCode().ToString(); } }
    public string Url { get; set; }
    public string Type { get; set; }
    public string Title { get; set; }
    public DateTime? PublishDate { get; set; }
    public string Content { get; set; }
    public string Excerpt { get; set; }
    public List<string> Categories { get; set; }
    public List<string> Tags { get; set; }

}

Starting from the bottom, the Page class represents the JSON objects that are output in the search.json, and the properties need to match 1 for 1 with the fields in the Index.

Each time we update the index we delete and recreate the index. We do this because if we delete a post or a page it gets removed from the search.json, but there is no way to trigger it’s removal from the Index. This could produce a result to be shown to the user that results in a 404.

Lastly (or firstly), the Run method gets the search.json from the blog, deserializes it into a List<Page> and uploads that list to the Search Index. Last I looked there was a limit of 1000 items per batch. I handle that potential problem in my GitHub example, but left that out here for simplicity.

Search Function

Finally, we’re able to start searching. First thing to do is create a Search function. To do this create an Http Trigger function and change the Authorization level from Function to Anonymous. By default the Url for this function will be /api/search. We’ll need to include a project.json with the same reference to the Azure Search SDK as we had in the BlogIndexer function. We’re also going to have a bit of duplicate code for the Page class and IndexClient (there’s ways to share code, but again trying to keep it simple for this post).

#r "Newtonsoft.Json"
using Microsoft.Azure.Search;
using Microsoft.Azure.Search.Models;
using Newtonsoft.Json;

public static async Task<HttpResponseMessage> Run(HttpRequestMessage req, TraceWriter log)
{
    // parse query parameter
    string search = req.GetQueryNameValuePairs()
        .FirstOrDefault(q => string.Compare(q.Key, "search", true) == 0)
        .Value;

    string cat = req.GetQueryNameValuePairs()
        .FirstOrDefault(q => string.Compare(q.Key, "cat", true) == 0)
        .Value;        

    var results = Search(search, cat); 
 
    return req.CreateResponse(HttpStatusCode.OK, results); 
}

private static List<Page> Search(string search, string facet)
{
    var queryApiKey = "[Your API Key]";
    var searchServiceName = "[You Search Service Name]";
    var searchIndexName = "[Your Index Name]";

    var indexClient = new SearchIndexClient(searchServiceName, searchIndexName, new SearchCredentials(queryApiKey));

    string facetFilter = "";
    if (!string.IsNullOrEmpty(facet))
    {
        facetFilter = $"Categories/any(c: c eq '{facet}')";
    }

    var searchParams = new SearchParameters();
    searchParams.IncludeTotalResultCount = true;
    searchParams.QueryType = QueryType.Full;
    searchParams.SearchMode = SearchMode.Any;
    searchParams.Top = 10000;
    searchParams.Select = new[] { "Url", "Type", "Title", "Excerpt", "Categories", "PublishDate" };
    searchParams.Filter = facetFilter;
    searchParams.Facets = new[] { "Categories" };

    var searchResults = indexClient.Documents.Search<Page>(search, searchParams);

    var pages = new List<Page>();
    foreach (var r in searchResults.Results)
    {
        pages.Add(r.Document);
    }
    return pages; 
}

public class Page
{
    public string Id { get { return Url.GetHashCode().ToString(); } }
    public string Url { get; set; }
    public string Type { get; set; }
    public string Title { get; set; }
    public DateTime? PublishDate { get; set; }
    public string Content { get; set; }
    public string Excerpt { get; set; }
    public List<string> Categories { get; set; }
    public List<string> Tags { get; set; }
}

Once that’s in place you can go to [Your function app URL]/api/search?search=foo&facet=bar and you should see some results. Don’t be shocked if it comes back as Xml, when you make the request from javascript on your page you can specify that you want JSON.

Before going on to setup search on the client side you need to update the CORS settings for the Function App. To do that through the portal you can click on Function app settings click on Configure CORS then add your blog’s domain and localhost:4000 to the list.

Searching

To do the search from my Jekyll based site I created a search.md page that looked for a search and cat query string and made a call to the API. Anywhere I started a search (clicking on a category or hitting enter in the search box), I forwarded the user to this search page with the appropriate query string.

On that page, I make a request to the Search function which returns a JSON of the results. I then loop through the results to build up some HTML as a string and stick it in the innerHtml of the appropriate element on the page.

My search page looks like this

---
title: Searching...
layout: search
includeInSearch: false
permalink: /search/
published: true
---

<script>
var query = getParameterByName('search');
var cat = getParameterByName('cat');
var tag = getParameterByName('tag');

document.getElementById("searchText").value = query;

getSearchResult(query, cat, tag);
</script> 

The JavaScript to actually perform the search and display the results.

var searchUrl = '[URL of the Azure Function that performs the search]';

function searchKeyPress(e){
    if (e.keyCode != 13) return;
    
    var searchText = document.getElementById('searchText').value;
    var cat = getParameterByName('cat');
    var tag = getParameterByName('tag');
    var catFilter = '';
    var tagFilter = '';

    if (!searchText) searchText='';
    searchText = encodeURIComponent(searchText);
    if (cat) catFilter = '&cat=' + cat;
    if (tag) tagFilter = '&tag=' + tag;
    window.location.href = '/search?search=' + searchText + catFilter + tagFilter
}

function getSearchResults(searchText, cat, tag) {

	appInsights.trackEvent("Search", { search: searchText, category: cat, tag: tag });

    if (!searchText) searchText = '';
    if (!cat) cat = '';
    if (!tag) tag = '';

    searchUrl += '?search=' + searchText + '&cat=' + cat + '&tag=' + tag;

    var xhr = new XMLHttpRequest();
    xhr.onreadystatechange = searchCallback;
    
    xhr.open('GET', searchUrl, true);
    xhr.send('');
    document.xhr = xhr;

    function searchCallback(){
        if(xhr.readyState === 4) {
            if(xhr.status !== 200) {
                alert('Search failed! ' + xhr.status + xhr.responseText);
                return;
            }
    
            var searchResults = JSON.parse(xhr.responseText);
            window.searchResults = searchResults;
            displaySearchResults(searchResults);
        }
    }
}

function displaySearchResults(searchResults){

	var response = '';
	var main = document.getElementById('main');	
    var section = document.getElementById('main').getElementsByTagName("section")[0];

    for (var x=0; x < searchResults.Results.length; x++)
    {
    	var r = searchResults.Results[x];
        if (r.Document.Type == "post") {
            var categories = "";
            for (var y=0; y < r.Document.Categories.length; y++)
            {
            	var c = r.Document.Categories[y];
                categories += "<a href='/search/?search&cat=" + c + "'>" + c + "</a>&nbsp;";
            }
            if (!categories)
            {
                categories = " in " + categories;
            }
            response += "<article class='post'> <header class='jumbotron'> <h2 class='postTitle'><a href='" + r.Document.Url + "'>" + r.Document.Title + "</a></h2> <abbr class='postDate' title='" + r.Document.PublishDate + "'>" + new Date(r.Document.PublishDate).toLocaleDateString("en-us", {year: "numeric", month: "long", day: "numeric"}) + "</abbr> " + categories + "</header> <div class='articleBody'>" + r.Document.Excerpt + "</div><div><a href='" + r.Document.Url + "'>Continue Reading</a></div></article>";
        }
        else
        {
            response += "<article class='post'> <header class='jumbotron'> <h2 class='postTitle'><a href='" + r.Document.Url + "'>" + r.Document.Title + "</a></h2></header> <div class='articleBody'>" + r.Document.Excerpt + "</div><div><a href='" + r.Document.Url + "'>Continue Reading</a></div></article>";
        }
    }
    if (response){
        section.innerHTML = response;
    }
    else{
        document.getElementById("searchMessage").innerHTML = "No results found."
    }
}

function getParameterByName(name, url) {
    if (!url) {
      url = window.location.href;
    }
    name = name.replace(/[\[\]]/g, "\\$&");
    var regex = new RegExp("[?&]" + name + "(=([^&#]*)|&|#|$)");
    var results = regex.exec(url);
    if (!results) return null;
    if (!results[2]) return '';
    return decodeURIComponent(results[2].replace(/\+/g, " "));
}

*It’s not quite free

I’m using the free tier of Azure Search, and Azure Functions allows 1 million function calls and 400k Gbs of execution for free. In theory, there is no charge unless it gets a lot of use.

But it’s still not quite free. I have been charged $.03. Looking at this, it turns out that some of that is from a couple of days when my function wasn’t compiling but was getting called by one of my Application Insights Web Tests. That caused the function to be reloaded from the Function App’s Storage Account racking up $.02.

The other $.01 has come from the App Service behind my Function App, but I can’t see where. There is no single day where there is a $.01 charge, so I’m guessing it’s the cummulation of fractions of a cent per day.

I’d like this to be 100% free, but I’m not going to spend my time finding out why I’m being charge $.03/month.

Addition resources

Source code for the Azure Functions that are handling search on this site, included is a Jekyll folder with most of what you’ll need to get it running on your site. The only things missing are the search box and the category displays that would like to /search?cat=[category name]

If you get stuck, I’d love to help. Feel free to contact me through any method available on my about page.

Sharing Code Between Azure Functions

Jeremy Hutchinson — Mon, 07 Nov 2016 00:00:00 UTC

Once I had my Azure Search Indexer Failure Notifier working as an Azure Function I needed to make it run on all of our Indexers. I had 3 choices for sharing common code:

Copy/Paste
Have one big function that checked every indexer
Find some way to share code between functions

Option #1 was right out. I’ve seen that turn ugly in the past and have no desire to create such a mess for future me or anyone else.

Option #2 is a pretty good option, and would have been the simplest path to done. I went with option #3 mostly to learn how to share code. I know that knowledge will come in handy some day.

Looking at the Samples of the azure-webjobs-sdk-script repository and noticed the Shared folder.

First thing I moved was my GetEnvironmentVariable method. I created a file called Settings.csx in the Shared folder and created a public static class to hold the method.

using System;

public static class Settings 
{
	public static string GetSetting(string settingName)
	{
        return System.Environment.GetEnvironmentVariable(settingName, EnvironmentVariableTarget.Process);
	}
}

Then at the top of the run.csx just put #load "../shared/settings.csx"

I can then replace my calls to GetEnvironmentVariable("settingName") with Settings.GetSetting("settingName")

That worked great, so I continued to try to move the meat of the index watcher code. I created a SearchIndexerWatcher folder under in the Shared folder and created an IndexerWatcher.csx there and moved all of the code for checking the index status to that file.

#load "../Settings.csx"

using System;
using SendGrid.Helpers.Mail;
using Microsoft.Azure.Search;

public static class IndexerWatcher {

    public static Mail GetFailureNotification(string searchService, string searchIndexer, TraceWriter log)
    {
        var apiKey = Settings.GetSetting("SearchApiKey");
        string body = "";

        var client = new SearchServiceClient(searchService, new SearchCredentials(apiKey));

        var status = client.Indexers.GetStatus(searchIndexer);

        foreach (var hist in status.ExecutionHistory)
        {
            if (hist.EndTime > DateTime.UtcNow.AddMinutes(-65) && !string.IsNullOrWhiteSpace(hist.ErrorMessage))
            {
                body += hist.ErrorMessage + Environment.NewLine;
            }
        }

        Mail message = null;
        if (!string.IsNullOrEmpty(body))
        {
            message = new Mail();

            Content content = new Content
            {
                Type = "text/plain",
                Value = body
            };

            message.AddContent(content);
        }
        return message;
    }
}

Notice that this code references the Settings.csx from the Shared folder.

Now my main function is just setting specifying the SearchService and SearchIndexer, then calling this function.

#r "SendGrid"
#load "..\Shared\SearchIndexerWatcher\IndexerWatcher.csx"

using SendGrid.Helpers.Mail; 

public static void IndexWatcher_Prod(SearchIndexer input, TraceWriter log, out Mail message)
{
    var searchService = "mySearchService";
    var searchIndexer = "myBlobIndexer";

    message = null;IndexerWatcher.GetFailureNotification(searchService, searchIndexer, log);    
}

So this mostly works as expected. The Run.csx has the #r to pull in the SendGrid reference and the #load to pull in IndexerWatcher.csx. IndexerWatcher.csx then pulls in Settings.csx.

Except when I created a new function for another one of our indexers it failed to compile because I forgot the project.json. And that’s where things get tricky. That project.json pulls the Microsoft.Azure.Search reference down from Nuget. We have no references to Microsoft.Azure.Search in the run.csx, so logically I’d like to put that in the Shared/SearchIndexerWatcher folder. But it doesn’t work from there, it has to be in the root of the function’s folder.

That’s not ideal because when I reuse the IndexWatch.csx later, I may not realize what dependencies need to be added to the project.json. I decided to leave the project.json in the Shared/SearchIndexerWatcher folder as a reference for what would need to be added to the function’s project.json.

Things I’m thinking about going forward:

Add a readme.md to the Shared/SearchIndexerWatcher folder to document how to use that file and what needs to be added to the project.json. Then remove the project.json.
Split the IndexerWatcher from the SendGrid Mail generation so that code can be shared more broadly.

Using Azure Functions to Detect Search Indexer Errors

Jeremy Hutchinson — Fri, 28 Oct 2016 00:00:00 UTC

Azure Functions are a light weight way to deploy code. It’s part of the “serverless” craze. While I admit I was suspect of serverless, after just this tiny foray, I can definitely see it’s usefulness.

So here’s my real world example of something simple you can do with Azure Functions. It’s just the tip of the iceberg, but it’s better than a Hello Word.

The problem I was trying to solve was that Azure Search Indexers don’t alert you when they fail to index a document. Depending on how you have your indexer configured it either ignores the document or it keeps retrying and gets stuck. In my case it got stuck. Luckily it was in our Test environment.

The goal of this was to create a watcher to periodically check the status of the indexer and send me an email if there were any errors.

Creating the Function App

The first step is of course to create the Function App through the Azure Portal. The setup is similar to setting up an Azure Web App right down to the [yoursite].azurewebsites.net. The Function App also creates a Storage Account that is used to store the code files.

Creating the Function

Whether you create your function through the portal or build it locally and deploy through continuous integration the file layout is the same, but not immediately obvious for some things.

[root]
| - host.json
| / IndexerWatcher 
| | - run.csx 
| | - function.json
| | - project.json (I had to add this file manually)

host.json allows you to control some settings at the Function App level (could contain multiple functions). By default it is an empty JSON. I’d prefer a file populated with the defaults, but you can see what settings are available and their defaults here.

function.json contains settings for the function include bindings which you can use to add inputs and outputs to the function. In this case we have a binding the timer trigger that runs the job at the top of every hour, and SendGrid send emails.

{
  "bindings": [
    {
      "name": "myTimer",
      "type": "timerTrigger",
      "direction": "in",
      "schedule": "0 0 * * * *"
    },
    {
      "type": "sendGrid",
      "name": "message",
      "to": "default@SendToEmailAddress",
      "from": "send@FromEmailAddress",
      "subject": "Default Subject",
      "direction": "out"
    }
  ],
  "disabled": false
}

project.json allows you to reference Nuget packages. In this case I’m referencing the Azure Search SDK so that I can get the status of the indexer. We could also do this through the Rest API, but I’m a big fan of strong typing and intellisense…

{
  "frameworks": {
    "net46":{
      "dependencies": {
        "Microsoft.Azure.Search": "1.1.3"
      }
    }
   }
} 

run.csx is the main script file. In this case it is C#, but it can be F#, Javascript, Powershell, Python etc. In C# it contains a function with the signature public static void Run().

We have additional parameters for the TimerInfo, TraceWriter and a SendGridMessage. We don’t need to configure any bindings for TraceWriter, it is always available to be passed into your function. The other two are configured in the function.json.

Because we’re using SendGrid and SendGrid is not automatically referenced, we need to tell the host to add the reference. We do that with the #r "SendGridMail" at the top. There’s a handful of external assemblies you can this way reference.

After that we just call the Search Service, request the Indexer Status and generate an email if needed. If I don’t need to send an email I just pass a null SendGridMessage back. That throws an error in the console, but I didn’t see any other way to not send the email. If there is a better way please let me know.

#r "SendGridMail"

using System;
using SendGrid;
using Microsoft.Azure.Search;

public static void Run(TimerInfo myTimer, TraceWriter log, out Mail message)
{
    var apiKey = GetEnvironmentVariable("SearchApiKey");
    //log.Info(apiKey);
    var searchService = "mySearchService";
    var searchIndexer = "myBlobIndexer";
    string body = "";

    var client = new SearchServiceClient(searchService, new SearchCredentials(apiKey));

    var status = client.Indexers.GetStatus(searchIndexer);

    foreach (var hist in status.ExecutionHistory)
    {
        if (hist.EndTime > DateTime.UtcNow.AddMinutes(-65) && !string.IsNullOrWhiteSpace(hist.ErrorMessage))
        {
            body += hist.ErrorMessage + Environment.NewLine;
        }
    }

    message = null;
    if (!string.IsNullOrEmpty(body))
    {
        message = new Mail();
		var content = new Content
        {
            Type = "text/plain",
            Value = body
        };

        message.AddContent(content);
    }
}

public static string GetEnvironmentVariable(string name)
{
    return System.Environment.GetEnvironmentVariable(name, EnvironmentVariableTarget.Process);
}

App Settings

From the Function App blade in the portal under Function App Settings there is Configure App Settings button. Click that and you can set your app settings just like you would for a Web App.

There are two app settings that you’ll need to configure to make this work.

SendGridApiKey - This is the SendGrid API Key and the setting name has to match or you get an error.
SearchApiKey - This is API Key for your Azure Search service. You can name this setting anything you like, but make sure you update the call to GetEnvironmentVariable in the run.csx.

TODO

As it is I’ll need to create a seperate function for each indexer I have (Prod, Test, Dev) which would mean duplicate code, which we all know is going to bite me in the ass. There is a way to share code between functions, but I haven’t explored it yet.
It wasn’t until after I had my first working Azure Function that I found the Azure-Functions-CLI. This should allow you to test the functions locally before deploying them to Azure.

Gotchas

I started developing this in a console app, and I needed to install the SendGrid v6.3.4 package to get it working there. Neither the 7.* nor the 8.* packages had the SendGridMessage class that was in the function’s method signature.

Update (11/30/2016)

With the general release of Azure Functions SendGrid was upgraded. I assume it was to the latest, but it was far enough that it broke my function until I changed SendGridMessage to Mail. This also required a change to how the mail was built. I’ve updated the code to reflect that.

Also, the application setting AzureWebJobsSendGridApiKey was changed to SendGridApiKey.

AWS Cloudsearch vs Azure Search

Jeremy Hutchinson — Wed, 12 Oct 2016 00:00:00 UTC

We recently started moving some of our bits from AWS to Azure. One of the first bits to go was the Search. Below is my comparison of the two.

tl;dr

Azure has the ability to automatically index data stored in SQL, DocumentDB, and Azure Table Storage as well as documents stored in Azure Blob Storage. Azure’s API is strongly typed and much more expressive than AWS’s.

Document Searching

This is a huge gap that AWS Cloudsearch currently has and is the whole reason we started moving to Azure. We needed to be able to search the contents of PDFs and Word Documents. In order to do this with AWS, we had 2 choices:

Buy a 3rd party library to allow us to read the contents out of the documents.
Pay for a service to watch our S3 storage and update a CloudSearch index for us.

The first option was prohibitively expensive both in time and money (not to mention added complexity). When I read the cost of the second option I almost fell out of my chair (ask me about it if you want a giggle).

Azure’s document search was still in preview, but I took a spike to see if was feasible and had a working prototype in less than a day.

So, document searching is real, decently well documented and was fairly painless to implement. It’s also totally automatic through Indexers.

Indexers

This is another feature only available in Azure. Indexers watch a datasource for new or changed data and update the search index as needed. It currently supports Azure SQL, SQL Server on Azure VMs, DocumentDB, Azure Blob Storage and Azure Table Storage.

Because our database still lives over on AWS we haven’t used this for our other search content, but if we did we could delete quite a bit of code that manages keeping the search index in sync with the source data.

The only downside is that (at least for Blob Storage) when you delete a document you need to mark it as deleted, wait for the indexer to run, then delete the document (or not, storage is cheap $.06/GB/month).

Creating the index

We did not script our index creation in AWS. We just created them through the AWS website. Really with our indexes, it’s hardly worth the effort to script them.

With Azure I started off the same way, but once I realized the only way to setup an Indexer for a Blob Datasource was through the REST API, I scripted everything. It took a little longer to get everything running the first time, but when in the process of development I realized I made a mistake in the config it was nice to just be able to delete it all, make one change and have all my environments updated.

Populating the index

With AWS Cloudsearch you need to create a JSON representation of the object you’re adding to the index. You can either upload that directly through their REST API or you can use their .Net API.

With Azure you can upload a strongly typed object to be indexed. Or you could build an indexer to handle all that for you.

Searching

This is where I really noticed a difference (We used the REST API for AWS so it might be a better experience with the .Net API). With AWS we needed to assemble a Lucene query in a URL query string. That means we’re doing a lot of string concatenation and managing when parentheses close.

With Azure the .Net API has properties for Skip, Top, Select, OrderBy and others that we were including in URL for AWS. That means instead of having to mange this:

&start=0&size=50

We just had to manage this:

searchParams.Skip = (int)search.StartRecord-1;
searchParams.Top = (int)search.EndRecord;

But the biggest boon was the seperation of Search and Filters. With AWS, everything was search. With Azure you have the concept of Filters. All of our filter fields are controlled by us, and they are just concatenated together using Azure’s ‘simple query syntax’ and added to the searchParams object. The search string the user enters is converted to a Lucene query (I open sourced my converter here).

This little bit of seperation has made a big difference and making the code easier to reason about.

Results

Again AWS is not strongly typed and just sends back a JSON document. We’re treating it as a dynamic and mapping it to something useful. You could also build a class to match the JSON and deserialize it.

With Azure the Search method is generic. Each search result contains a Document property that is the type you specified. Simple use the same type as the object that was uploaded and Bobs your uncle.

Summary

We really had no choice but to move to Azure because of its ability to index office documents. But the addition of automatic indexers and the strongly typed and well thought out API make me glad we made the move. The move from AWS Cloudsearch to Azure Search took a couple of days work (excluding moving document storage from S3 to Azure Blob).

Moving from AWS to Azure

Jeremy Hutchinson — Mon, 03 Oct 2016 00:00:00 UTC

We recently started moving from AWS to Azure. It’s something I had been pushing for, but the reason we finally started was because of the ability to index and search documents stored in Azure Blob storage, so the first things to move have been document storage and search. We expect to move our website, API and SQL database next, but we haven’t scheduled anything.

Below are some of the differences and lessons I found/learned in the process. I’ll also try to post some specifics about each service we move for comparison sake.

Documentation

The first thing I noticed when moving from AWS to Azure is the documentation gap. Finding documentation and examples for AWS seems exceedingly difficult. Both at docs.aws.amazon.com as well as on StackOverflow and through Google searches.

In contrast both Google and StackOverflow both bring up the examples I need when searching for questions about Azure, but even better is the Azure documentation. When you create a new resource in Azure the first blade that opens in the portal has QuickStart icon that will take you to the documentation including example code for how to create and interact with the services.

API

The next thing I noticed is that with AWS almost everything we’re doing is going through their REST API, with almost nothing happening through their SDK. I suspect that at least some of this has to do with how the original developer implemented it in our product. But some of the blame goes to AWS because the examples of how to interact with their services are by default through their REST API, and it takes some digging to find any documentation on how to do the same through their .NET SDK.

Also, the AWS .NET SDK is really just a wrapper around their REST API to the point that when uploading a document to Cloudsearch you upload an UploadDocumentRequest object which has 3 properties:

- ContentType (JSON or XML)
- Documents (System.IO.Stream of JSON or HTML representation of documents)
- FilePath (Path to a JSON or HTML representation of documents)

So they basically have an SDK that takes some strings.

In contrast, Azure’s SDK allows you to upload an IndexAction<T>. You create a strongly typed object, pass it to the SDK and it maps itself to your search index.

Organization

Both Azure and AWS have something called Resource Groups, but they aren’t really the same thing. In Azure Resource Groups are required when creating a service. I created Dev, Test and Prod Resource Groups in Azure to keep our services organized. Each service can only be in one Resource Group, so even though we have all our environments piggy backing on our Production search instance (separate indexes), that Search service can only live in one Resource Group. I put it in Prod so no one does anything stupid.

In AWS Resource Groups are optional. We haven’t been using them, but they look pretty neat. It’s all based on Tags, so one resource could be in multiple groups. You can also require multiple tags when selecting the items in a resource group. Again, we’re not using this feature but I assume that if I add a new service with a tag that is already part of a group that service will just appear in that group.

The one thing Azure Resource Groups has been invaluable for is experimenting. Want to play around or build a demo? Create a resource group for that, when you’re done, delete the Resource Group and all of your services are automatically deleted for you.

Azure also has the concept of Tags, but I couldn’t find a way to view the intersection of 2 tags.

Correct Me If I’m Wrong

Did I get something wrong here? Did something change? Let me know and I’ll get this updated.

Connecting AWS VPC to Classic RDS

Jeremy Hutchinson — Wed, 28 Sep 2016 00:00:00 UTC

A while back we did an audit of what we were spending through Amazon Web Services to see if there was any way we could reduce our spending without having a negative impact on our users.

One of the big things we found we would be able to do was upgrade some of our production EC2 instances from for AWS’s older m1.medium to an m3.medium, and our dev/test instances could downgrade from m1.small to t2.small.

The catch was we needed to create those instances in AWS’s Virtual Private Network (VPC), and there is no documentation for how to connect that VPC to things running “Classic Mode”. Our database was running on a RDS instance that was in Classic Mode and we didn’t want to incur the downtime to move that to a VPC.

Here’s how we eventually were able to get our VPC instance to talk to our classic mode RDS.

Create the VPC with a CIDR of 10.0.0.0/16. This also creates a single Route Table name that one Through NAT
Create second Route Table and call it Through IGW
Create a Public Subnet with a CIDR of 10.0.0.0/24
From the Route Table tab of the Subnet click edit and select the Through IGW Route Table from the dropdown
Create a Private Subnet with a CIDR of 10.0.1.0/24
From the Route Table tab of the Subnet click edit and select the Through NAT Route Table from the dropdown
From the Subnet Association tab of the Through IGW Route Table click edit and select the Public Subnet.
From the Subnet Association tab of the Through NAT Route Table click edit and select the Private Subnet.
Create an Internet Gateway and make a note of it’s ID
Select the Internet Gateway and click Attach to VPC to attach to your VPC
Edit the Routes of the Through IGW Route Table to add a route with 0.0.0.0/0 as the destination and the ID of the Internet Gateway as the target
Create a NAT Gateway, select the Private Subnet and create a new EIP
Edit the Routes of the Through NAT Route Table to add a route with 0.0.0.0/0 as the destination and the ID of the NAT Gateway as the target
Add the Elastic IP associated with the NAT Gateway to the allowed IP addresses in the Securit Groups section of the RDS dashboard
Cross your fingers

Connecting their two different styles of networks is something that I think should be built in to AWS’s tools. Not only is it not worked in, but when I contacted support about this they said it was impossible. I would have taken their word for it if we hadn’t already had this running to allow a webserver in one datacenter to talk to RDS in another.

If this doesn’t work, I’d be happy to try to help you figure it out and more importantly I’d like to update the steps so others don’t strugle.

Debugging IIS App Pool Crashes

Jeremy Hutchinson — Fri, 27 May 2016 00:00:00 UTC

We had a problem where a stack overflow error was crashing our App Pool in IIS. Other than that we didn’t have any information about what was cause was, what code was causing the crash or even what request.

This was my first time taking a crash dump and using it to debug and I was surprised at how painless it was. I’ll definitely be using this technique again.

Enable Crash Dumps in Windows Error Reporting

The first thing you need to do is change some registry settings to tell Windows Error Reporting to save a crash dump.

Open RegEdit and Create this key

[HKEY_LOCAL_MACHINE\Software\Microsoft\Windows\Windows Error Reporting]

Then set the following values:

Name	Type	Value
DumpFolder	Expandable String	c:\temp
DumpCount	DWORD	10
DumpType	DWORD	2

I found the DumpType setting to be the critical. The default is 1, which is Minidump, but that didn’t seem to be enough information to get me to the offending code. For reference my minidump was 48MB, my full dump was 800MB

Crash

At this point you can just sit back and wait for the next crash or you can cause it if you know how. When a file shows up, copy it to your dev machine and rename the key to LocalDumps_NO to prevent further dumps from accumulating while you work.

Debug

Open your solution in Visual Studio and checkout the same code that is running on the server. Build with your production configuration.
Drag the .dmp file into Visual Studio to open it.
Click Set symbol paths and add your project’s /bin folder
Click Debug with Managed Only

At this point you should be brought to the line that threw the exception. You can’t step though the code at this point, but you can see the values of your variables, and you can see how you got to that point with the call stack window (Debug->Windows->Call Stack or ctrl+D,C).

T4 Angular Template Cache

Jeremy Hutchinson — Fri, 31 Jul 2015 00:00:00 UTC

There’s a few ways to handle you’re angular directives and they all suck for different reasons.

Store them inline in your directives

The advantage to this method is you don’t have to make a separate web request, and it’s the simplest way to approach templates. This is where I started putting my templates, and I continue to put some templates here if they are very small and more important, simple.

The downside is that your HTML is stored as strings, so you lose any syntax highlighting and checking your IDE might provide. It can also result in some duplication if by chance you have two directives that would have the same HTML, but different logic, but that’s probably an edge case.

Store each in it’s own HTML file

This basically the exact opposite side of the coin from storing them inline. You have to make a separate request, but you pick up the syntax highlighting and checking from the IDE.

This is what I used for larger templates when they become too big or complex to keep inline.

Add them to the template cache

This option can avoid the extra HTTP request assuming you either put all your templates in one file, or bundle all the template JS files. But again, your templates are strings, so you lose all IDE support.

$templateCache.put('templates/search', 
    '<input type="text" ng-model="searchText" ng-enter="search()"/>'
);

Best of Both Worlds Through the Magic of T4

With a fairly simple T4 script we can store our templates in their own separate HTML files the way we want to work while developing. Then on build we can process those files to generate a single script file with all of the templates in it the way we want to deploy.

<#@ import namespace="System.Diagnostics" #>
<#@ import namespace="System.Linq" #>
<#@ import namespace="System.Collections" #>
<#@ import namespace="System.Collections.Generic" #> 
<#
#>
appModule.run(['$templateCache', function($templateCache) {
<#
	var projectPath = Directory.GetCurrentDirectory();

	if (projectPath.EndsWith(@"\bin"))
	{
		projectPath = projectPath.Substring(0, projectPath.Length - 3);
    }
	else
	{
		projectPath = Host.ResolvePath("");
		projectPath = projectPath.Substring(0, projectPath.Length - 11);
    }

	var templateDirectory = new DirectoryInfo(projectPath + @"templates");
	var files = templateDirectory.GetFiles("*.html");

	foreach(var file in files)	
	{
		
		var reader = file.OpenText();
		var template = "";
		while(!reader.EndOfStream)
		{
			var line = reader.ReadLine();
			template = template + line.Replace("'", @"\'");
        }

#>
$templateCache.put('templates/<#= file.Name #>', '<#= template #>');
<#}#>
}]);

A Couple of Things Worth Noting in This Script

The line if (projectPath.EndsWith(@"\bin")) is checking where we are running. If the path doesn’t ends in \bin, we know we’re building from inside Visual Studio and can use Host.ResolvePath("") to get the directory the .tt file is running and walk back from there substring isn’t ideal, but the traditional .. didn’t work so…).

If we’re running from outside Visual Studio we get the bin directory and just need to back up from there.

After that we just get the list of *.html files, read then into strings and add those strings to the cache.
Notice that I include the whole file name as my template name. This means that if my directive already had templateURL: 'templates\search.html' it will find that template in the templateCache and not make a request to the server.

Running the Template on Build

I added a Pre-Build Event to do the transform. I did this so that the template.js that is checked into source control matches what is in production. And to make sure any changes made to the HTML files are automatcially included.

"%PROGRAMFILES(x86)%\Common Files\microsoft shared\TextTemplating\11.0\TextTransform.exe" $(ProjectDir)Scripts\App\Templates.tt

For Easier Debugging

Lastly, for easier debugging I added a compiler directive in my bundle config around the templates.js.

    bundles.Add(new ScriptBundle("~/bundles/app.js").Include(
        "~/Scripts/app/app.js",
#if !DEBUG
        "~/Scripts/app/Templates.js",
#endif

This means that when I’m working locally in DEBUG mode I can load the template straight from the HTML and not have to worry about re-running the T4 Transform after every change. That keeps my loop short during development and keeps the number of requests down during production.

XPath to Select Node Based on Child Node's Attribute

Jeremy Hutchinson — Thu, 25 Jun 2015 00:00:00 UTC

Thankfully I don’t use XPath frequently, but every time I do I end up having to google something. Today was no different except that my googling turned up nothing on my problem.

I needed to select a node based on the attribute of one of it’s child nodes. Simple right?

In this case I’m trying to find all the topics where a certain image is used.

<Topics>
	<Topic>
		<Title></Title>
		<Description></Description>
		<Content>
			<Image Id="123" />
			<ContentPart />
			<ContentPart />
		</Content>
	</Topic>
	<Topic>
		<Title></Title>
		<Description></Description>
		<Content>
			<ContentPart />
		</Content>
	</Topic>
</Topics>

It’s simple as long as you know how deep to look for the attribute

/Topics/Topic[Content/Image[@Id='123']]

But in my situation those images could be anywhere in the topic. I couldn’t specify the path to take through the tree to search for the image element.

<Topics>
	<Topic>
		<Title></Title>
		<Description></Description>
		<Content>
			<Image Id="123" />
			<ContentPart />
			<ContentPart />
		</Content>
	</Topic>
	<Topic>
		<Title></Title>
		<Description></Description>
		<Content>
			<ContentPart>
				<Image Id="123" />
			</ContentPart>
		</Content>
	</Topic>
</Topics>

The answer was elusive for longer than I’d care to admit. I’d either get all the Topic elements or none. Here’s one of the ways I got all the elements.

/Topics/Topic[//Image[@Id='123']]

In hindsight I can see the [//Image[@Id='123']] was going to search the whole document for Image elements with Id of 123.

There are a seemingly infinite number of ways to get no Topic elements returned. Including many ways that are just invalid XPath.

What finally did work was the . operator. It selects the current element

/Topics/Topic[.//Image[@Id='123']]

In the end it was simple, but I couldn’t google up an answer, so we get a blog post. Hopefully this will help the next person struggling with the same issue, and hopefully I’ll never write another XPath query after this project ;)

Prematurely Optimizing My Blog

Jeremy Hutchinson — Thu, 04 Jun 2015 00:00:00 UTC

This blog isn’t what you’d call ‘high traffic’. My big problem wasn’t load, it was keeping the site ‘warm’, so each user didn’t have to wait for WordPress to spin up and before serving the first page. Of course once I started looking at performance I went fully down the rabbit hole and came out on a different blogging platform.

I have an MSDN subscription and some unused Azure credits, so the first thing I did was move my WordPress site to Azure. It was as simple as spinning up an WordPress site on Azure through the wizard, exporting from my old site and importing at the new one. I used the azure credits to host it in an ‘Always On’, Small, Basic, Web Application paid for by Azure credits. I quickly learned that the free MySql DB provided needed to be upgraded to a paid level costing $10/month.

I actually perceived this to be slower, especially in the admin screens which frequently took 7+ seconds to load. The main site was a little faster.

I wasn’t worried about the slow admin screens (though it was driving me crazy), but I did want to improve speed for users.

I added a W3 Total Cache which was supposed to be able to handle bundling, minifying CSS and JavaScript, moving script tags to the end of the page, and caching the site to static pages. It failed both on bundlig, minifying and moving the tags (I also tried other caching plugins which failed similarly.

I added Autoptimize which bundled and minified the CSS and JavaScript. And I added Speed Booster Pack which moved my script files to the end of the page.

At the end of all this I had decent performance.

I was still getting things flagged by Google’s PageSpeed as well as in YSlow. There were things that I just couldn’t easily control that I really wanted to fix. And it started to bother me that I had increased my hosting costs when I was expecting them to decrease.

I looked at a bunch of blogging platforms and ended up settling on PieCrust CMS which is a static site generator.

A static site generator creates you’re site in plain HTML on your machine and you upload that to your webhost. You can serve it out of any web host, or some interesting alternatives like Amazon S3, DropBox, or the one I eventually settled on GitHub Pages.

Once I went to a static site, performance went through the roof. First I tried hosting it in Azure in a a Small, Basic, Web Application.

This is where I started to get a little obsessive. I tried putting a CDN in front of my static site in Azure.

Then just for giggles I tried GitHub Pages. And was shocked to see it was faster still

Your website is faster than 99% of all tested websites

I should have stopped there, but I felt there was still a lot I could do. I removed all the fancy web fonts. I returned excerpts instead of full posts. I removed FontAwesome and instead hunted down jpegs for the few social icons. I stripped out any unused CSS.

I brought the total pageweight down 297k to 39k and reduced the number of requests by 18. In the end my results were almost everything I hoped for.

You’ll notice my score is still 88/100. This is because GitHub pages doesn’t let you set expires headers, so assets you should only have to request once (my picture, social icons, css and js) get requested every time and every the response is 304

I’d love to see that fixed, but I think it’s time to leave well enough alone, besides I have this to hang my hat on

Your website is faster than 100% of all tested websites

The look and feel of my new website is essentially the same as it was when on WordPress. It’s based on the Author theme.

Blog Engines Compared

Jeremy Hutchinson — Mon, 01 Jun 2015 00:00:00 UTC

I loved WordPress in so many ways. There were hundreds of styles to choose from, a huge library of plugins, analytics, and performance problems. I’m not saying that WordPress can’t be configured to give adequate (or even excellent) performance, but I either didn’t have the knowledge or the money to do so.

tl;dr: I went with PieCrust CMS which is a static site generator. It’s easy and it is fast as hell. The downside is no built in search, but we always have Google.

Disclaimer: I’m a .Net Developer and currently have some credits laying around in Azure so I was really looking to take advantage of that and so that probably limited my options.

So, I went looking for other blog engines, and here’s what I found.

I’m just going to list the blog engines I tried and why I didn’t use them. This is roughly the order that I tried them and I might have landed somewhere else if I had gone in a different order.

WordPress

This is where I started. WordPress is ubiquitous for a reason. It’s really easy to get running and easy to operate. There’s an enormous number of plugins and themes to choose from, and it can really run just about anything. I started on WordPress years ago exactly because it was easy.

The problem for me was performance. I was seeing page load times between 4-5 seconds, sometimes longer. I did put a lot of effort into optimizing WordPress. And I had some great success. I cut my page weight and number of requests by 75%, and my page load time dropped by more than half down to a hair less than 2 seconds. In the process I got really focused on performance and more importantly realized WordPress was much more than I needed.

Umbraco

I actually played a key role in choosing this as the CMS system for a previous employer. It replace Dot Net Nuke, and the developers really liked it (I actually didn’t develop with it). One of the things I was trying to get away from was the cost of a database. If a few years down the road I no longer have Azure credits, this option gets really expensive. I didn’t even stand up an instance, but it might be worth investigating yourself.

DasBlog

If it’s good enough for Scott Hanselman it’s good enough for me right? Nope. I found the admin UI fairly impenetrable, or maybe I just didn’t want to try to penetrate it. It just looked old and clunky. And it is old. A quick look at CodePlex shows it was last updated in 2012. I didn’t give it a fair shake, I just moved on.

Ghost

This felt like a nice fast blog. And this is where I started to really start measuring. But I couldn’t see how to setup a theme or modify the CSS. Did I need to FTP in, and make changes there? Again I just kind of moved on without giving it a fair shake. But I will say this, it was fast.

BlogEngine.net

I was strongly considering going with BlogEngine.net. Aside from WordPress, it was the only one that had search built in. That struck me as a bit odd because I probably search my own blog 5-6 times per year. And use search on other people’s blogs more frequently than that. It had some free themes, but nothing I really liked. While looking at building my own theme I stumbled on MiniBlog and since they are both built by Mads Kristensen (yes, of Web Essentials fame) and both use the same format for storing their posts I figured I’d use the newer MiniBlog and I could easily switch back if I decided I really wanted built in search.

MiniBlog

I really liked MiniBlog. It was really stripped down and really fast. I went as far as building out my whole theme (based on the theme I was using with WordPress). This is a big deal for me. I usually just hand anything CSS related off to a front end guy. I had chosen MiniBlog. I even had a few pull requests merged to fix some bugs I found (my first open source contributions!)

One of the things I really liked was Windows Live Writer integration. This was one of the biggest selling points. It also turned out to be the reason I ditched MiniBlog.

The nice thing about Windows Live Writer is that you can write locally then click the publish button and whoosh, your post is live. But the post was just stored on disk in the cloud. There wasn’t any backup mechanism like I had with WordPress. And to make matters worse, I was modifying the source, so there was a chance that during one of my deploys I could wipe out my history.

The best I could come up with was to run locally, publish to the local instance from Windows Live Writer then push the whole thing live.

Pretzel

This was my first look at static site generation. The idea is that instead of rendering the blog post when the user comes to your site you render it locally then push the rendered page up. The blogging is done in MarkDown. It’s pretty nice, and it’s supposed to be a Jekyll clone, but there’s not a lot of documentation or examples and some things from Jekyll that I tried didn’t work.

Jekyll

“Pretzel seemed to be missing some features, maybe I should try going right to Jekyll.” - Me 45 minutes before giving up.

As I said at the start, I’m a .Net Developer. And though I think I could figure out how to get Ruby installed, and Jekyll and it’s dependencies. After 45 minutes I gave up. If it’s that hard to get to “Hello World”, I’m not sure I want to go further.

Also, since posts are written in MarkDown, if I used another MarkDown based static site generator I’d have little trouble switching.

PieCrust

Like Pretzel and Jekyll, PieCrust is a static site generator. And it mostly “Just worked”. I ran into a few problems, but when I reached out to it’s author, Ludovic, on twitter he responded with fixes and workarounds within an hour or two.

Again, it’s a static site, so to create a post you create a MarkDown file in a specif folder (or tell PieCrust to create it for you). Write your post in that file, then tell PieCrust to build the site for you. Then you upload the whole site.

And of course, since it’s a static site, it’s as fast as file transfer. My home page is 36k and takes about a half second to load. I’m hoping you noticed ;)

The only downside is there is no built in search. Because it’s static. I’ve seen some interesting workarounds doing a string matching search in clientside JS, but I went with Google. I think the only problem there would be recent posts might not be indexed. Trade-offs, there are always trade-offs.

My First NoSQL Table

Jeremy Hutchinson — Tue, 19 May 2015 00:00:00 UTC

I come from a relational database background. Specifically I’ve been using Microsoft SQL for 18 years. At this point data modeling for a relational database is second nature. Data modeling in NoSQL on the other hand has been somewhat mysterious to me. I’ve read up on some of the strategies for where to break NoSQL data into separate tables, but have had little real world experience.

The lack of real world experience has been two-fold. First I haven’t seen a NoSQL database designed by someone who really knew their NoSQL data modeling, and I haven’t done much NoSQL data modeling which might allow me to see where things become problematic from being too normalized or too denormalized.

At my job we are using some NoSQL (AWS DynamoDB). The main application uses an MSSQL database and we mostly use DynamoDB for it’s ability to replicate some performance critical data across regions so that our European customers don’t have the latency of crossing the Atlantic for everything.

But, recently I had a bit of an epiphany when I was adding a rule builder to our project. Each rule could have multiple conditions and groups of conditions., and the groups could also contain other groups. By default I put the data into a Rules, Groups, and Conditions tables in the database. That was working fine initially, but the recursion started to become a problem.

Recursive data structures can be problematic in SQL. You need do a series of left joins for each level of recursion, and you need to decide in advance how many levels of recursion you’re going to allow.

select *
  from Rules r
  left join Conditions c1 on r.RuleId = c1.RuleId --Level 1 Conditions
  left join Groups g1 on r.RuleId = g1.RuleId --Level 1 Group
  left join Conditions c2 on r.GroupId = c1.GroupId --Level 1 Group Conditions
  left join Groups g2 on g1.GroupId = g2.ParentGroupId --Level 2 Group
  left join Conditions c3 on r.GroupId = c3.GroupId --Level 2 Group Conditions

To do this with Entity Framework you need to do something like

var rules = from rule in db.Rules
    .Include("Conditions, Groups.Conditions, Groups.Groups.Conditions")
    select rule;

You could of course lazy load the groups and conditions, but that’s a recipe for performance disaster. This is going to be the classic N+1 problem, only since it’s recursive it’s the N1+N2+N3+1.

After a night of chewing on the problem I decided that the answer was to store the Rules in DynamoDB. I simply created a Rules collection and plopped the whole Rule right in. Each rule is now one object in the a NoSQL table. No joins necessary and no worry about N+1 performance issues.

It’s so blindingly obvious in hindsight that I’m surprised I never thought of it before, and I almost certainly won’t attempt to store a recursive data structure in a relational database again.

The Perfect Job

Jeremy Hutchinson — Thu, 14 May 2015 00:00:00 UTC

Occasionally after telling a recruiter that I’m not interested in a position (yes, I try to respond to the ones that are not obviously spam) they’ll ask what I am looking for, which is an odd question since I’m usually not looking. I usually list a couple of things, but from this day forward I will refer them to this post. Also, my boss asked me if there was anything the company could do to make things “better for you and the rest of the team”. So here it is, a description of my ideal job, with the full knowledge that it almost certainly doesn’t exist, and tradeoffs will be made.

The list is somewhat of a priority order.

Team

The team, more than any other aspect, can make or break a job. I want a team of really smart people. And not just smart developers, but smart managers, product owners, QA, design etc. And not just smart, they should be open to sharing their knowledge as well as learning from others. Smart enough to have strong opinions, but humble enough to let others run with their ideas even when they disagree.

The Work

It isn’t about what I’m building, it’s about how we build it. I don’t want to build a mediocre anything. I want to work on a project where the goal is to create the best X. I want to have time to make sure it’s being built well, that’s it’s well tested, that it scales as needed, and most importantly that it’s maintainable.

That doesn’t mean I want perfection from the outset. I understand tradeoffs will be made, but we should be striving towards excellence, not mediocrity.

Work Environment

The key to work environment for me is quiet. Ideally that would mean an office with a door, maybe one officemate. If it’s a team room or open plan, there should be an expectation of near silence. That means whenever possible people take their phone and other conversations in a different room.

I already have my perfect office in my house and really prefer working on remote teams. The key here is that the team needs a remote mindset, not an office based team with an office based mindset with 1-2 remote developers. Meetings can be very difficult if it’s a room full of people talking and I’m the only one on Teams/Zoom.

Compensation

I’d still write software if I were independently wealthy, but I just wouldn’t have a “job”. So yes, the job needs to pay. I never want money to be the deciding factor in taking a job. It can easily be the deciding factor if the salary is too low but is unlikely to be the deciding factor otherwise.

Bonuses

This is the section where companies can really differentiate themselves. Some of these perks are worth more than others, but I didn’t make any attempt to put them in any kind of order.

Work from home (full time or even part time)
Send the team to a conference
Pluralsight or other similar subscription
Flexible schedule
Latest software (should be on the latest version of Visual Studio)
Excellent hardware
Budget for tools like Resharper, Semantic Merge, etc
MSDN Subscription
Time and/or encouragement for blogging
Help with speaking at conferences (time off and/or travel covered)

What’s not Listed

I didn’t list the typical trappings of ‘startup culture’ like free massages, gym memberships, lunches, soda, beer, or whatever. Those are nice, I’ve had some of them before, but they are just not something that would sway me. Some of them are even red flags.

Recruiters, please include the word “tradeoffs” in the first line of your email so I know you read this.

Scheduled Jobs in Azure

Jeremy Hutchinson — Sat, 25 Apr 2015 00:00:00 UTC

Have a process you need to run periodically on your Azure hosted application? It’s simple to do with Azure Scheduler.

From the Azure Management screen (not currently available in the new portal) click New->App Services->Scheduler->Custom Create

This will open up the job creation wizard. First you need to create a Job Collection. You can choose your region, you probably want it to be located in the same Region as your Web Site, but you may have a reason you want it hosted somewhere else.

Give your job a name, select the type of job HTTP, HTTPS, or Storage Queue. For this example I’ve just chosen an HTTP Get call to a URL that doesn’t actually exist on my blog.

Then select the schedule.

So in this example the Azure Schedule is going send a Get request to /jobs/dostuff every minute. All I need to do is implement what I need done in that controller action.

A couple things to note:

By default it puts you on the Standard plan which is $13.99/month. You can use the free tier if you have 5 or less jobs and they don’t need to run more frequently than hourly. You need to edit the job after you create it to switch to the Free tier.
When you’re editing a job you have the option to add headers and/or basic auth.
You can call any public URL, so you're not limited to only calling URLs that are hosted on Azure.

C#6 String Interpolation

Jeremy Hutchinson — Tue, 31 Mar 2015 00:00:00 UTC

Another feature I’m looking forward to in C#6 is string interpolation. We’ve all had to create string messages to show the user that include data from the application, or maybe we’re just writing some debug information to the console. We can build these messages a few ways right now.

//string concatenation
logMessage = "User '" + userName + "' logged in at " + loginDate.ToString();

//string.Format
logMessage = string.Format("User '{0}' logged in at {1}", userName, loginDate.ToString());

C#6 gives us a third method – String Interpolation. This allows us to include expressions directly in our string literals. Just place the value between 2 curly braces.

logMessage = $"User '{userName}' logged in at {loginDate}";
//User 'jrhutch' logged in at 3/31/2015 2:03:31 PM

You can also apply formatting to the values

myString = $"User 'I spent {54.235 :C2}' at {someDate : HH:mm}";
//I spent $54.24 at 14:04

Or if you really want to get crazy (and I’m not sure I’d take it this far), you can use a conditional expression to decide the content of your string

msg = $"{unreadCnt} unread {(unreadCnt == 1 ? "message" : "messages")}";
//1 unread message
//2 unread messages

I wouldn’t say I’ll be doing all my string generation with interpolation, but it sure is nice to have another tool in the box.

Why You Should Give a Lightning Talk

Jeremy Hutchinson — Mon, 02 Mar 2015 00:00:00 UTC

I previously posted that I had appointed myself Community-Booster, and so I now see it as my job to convince you to give a lightning talk at your local user group. I could start by listing the benefits to you, or to the benefits to the user group, but I don’t think the for most people the fear of things going poorly outweigh the potential benefits. So let’s focus on your fears.

“I have nothing interesting to present” – This is very unlikely to be true. You spend every day working with code, there is at least one concept that with a bit of preparation you talk about for 15 minutes.
“I have nothing original to present” – This one is very likely to be true, but it doesn’t matter. You don’t need an original idea, you just need your take on an idea. I didn’t discover the techniques I used in my Cross Platform Development talk, I collected a bunch of different techniques that others have shared through documentation, blog posts and even other presentations and compiled them into a larger talk. I presented the Repository Pattern in a lightning talk and I sure didn’t come up with on my own.
“I’m not a good public speaker” – This could be true, but it doesn’t mean you can’t become a decent or good public speaker and the only way to improve is to get out there an speak. What better place to do that than in a room filled with people who tend to not be great public speakers, they’ll will be a forgiving bunch.

The positives break down into two categories

Makes you more hirable – If you submit a resume and somewhere on there it says that you spoke about X technology at your local user group that should pique the hiring manager’s interest even if they don’t use that technology. It shows that you take an interest in improving yourself. It shows that you know or researched a topic enough to be able to present it. It also shows that you can communicate, which is something that can be hard to show on a resume. Most importantly it shows that you’re willing to share your knowledge, that you’re willing to spend your time and energy to help others become better developers.
Improves your developer Community – Every lightning talk I’ve ever heard helped me in some way. It’s not that I’ve been able to apply the knowledge immediately, but I’ve taken what I’ve learned and filed it away for future use. Even the design patterns talks were helpful, I’ve read books on design patterns and have implemented a fair number of them, but having someone step through one is still educational. Most importantly, you might inspire someone else to speak.

I’m not going to lie, becoming more hirable was my primary motive for blogging and speaking when I started. Now I’m focused more on improving the community. I learn so much from other people’s contributions through blog posts, answering questions on forums and speaking at user groups that I feel obligated to give back to that community. The more of us who give back, the better we all become.

Null Conditional Operator

Jeremy Hutchinson — Mon, 23 Feb 2015 00:00:00 UTC

There are a bunch of cool features coming in C#6, but the one I’m looking forward to the most is the Null Conditional Operator. Developers write a lot of code to check if a value is null. Sometimes it creates a deep and ugly nest of if statements. Let’s say you are trying to find a customer’s primary contact’s city, it might look like this:

string primaryContactCity;
if (customer.PrimaryContact != null)
{
    if (customer.PrimaryContact.Address != null)
    {
        primaryContactCity = customer.PrimaryContact.Address.City;
    }
}

Or maybe you prefer less nesting and instead use a longer if statement:

string primaryContactCity;
if (customer.PrimaryContact != null && customer.PrimaryContact.Address != null)
{
    primaryContactCity = customer.PrimaryContact.Address.City;
}

With the new Null Conditional Operator you can just put ?. in place of the .. If the value to the left of the ?. is null it returns null otherwise it returns the property to the right. These two bits of code return the same thing:

Address primaryContactAddress;
if (customer.PrimaryContact != null)
{
    primaryContactAddress = null;
}
else
{
    primaryContactAddress = customer.PrimaryContact.Address;
}

Person primaryContactAddress = customer?.primaryContact.Address;

So the deep nest from above can be re-written as:

string primaryContact = customer?.primaryContact?.Address?.City;

It starts to get some real power when you use it in combination with the Null Coalescing Operator ?? In the following code we return the City as ‘Unknown’ if the PrimaryContact is null, or if the Address is null, or the City is null.

string primaryContactCity = customer.primaryContact?.Address?.City ?? "Unknown";

Community-Booster

Jeremy Hutchinson — Tue, 17 Feb 2015 00:00:00 UTC

A little over a year ago our local .Net User Group shut down (Maine Bytes). The guy who had been running it for 10+ years decided he didn’t want to continue the work, and rather than find someone to fill his shoes he just shut it down (if you want to hear a rant ask me what I think about that decision).

Maine Bytes seemed to encourage passive attendance, not participation. I’m not sure if was intentional or if it was the space (rows of tables facing the speaker) or just a vibe the group developed, but I frequently went and rarely talked with anyone. They usually had a seasoned speaker come in from out of the area and the group (myself included) began to expect that. The one time the group held a “member lightning talk” night, I think it came as a surprise, and I’m ashamed to admit I was a little put off, that we had inexperienced speakers.

When Casco Bay .Net User Group filled the gap, their second meeting was a “member lightning talk” night. At my co-worker’s urging (he is one of the organizers) I presented a gave a quick talk on Automated UI Testing with Selenium. I really enjoyed speaking, but I also really enjoyed the other lightning talks. They were compact and informative.

That night was enough to encourage me to speak at Boston Code Camp, then Vermont Code Camp as well as a few more CBNUG lightning talk nights. I’ve really enjoyed each of these events for their own reasons, but Vermont Code Camp really stirred something in me.

Two things happened the week of Vermont Code Camp that changed the way I look at our user group.

Russ Fustino spoke to our group about Xamarin Forms, which was a great, but at the end he said “Where are we all going to get a beer?” The question wasn’t “does anyone want to get a beer?”, the assumption was that we were all going to the bar and he wanted to know where. This was the first time we went for drinks after any user group meeting I’d ever been to, and it really broke the ice for the group.
I went to Vermont Code Camp. At first I was excited to see how many names I recognized as seasoned speakers I’d seen at bigger conferences or recognized from Twitter. But what really impressed me was the quantity and quality of speaker from Vermont. It made me realize that these speakers probably got their starts at their local user group (VTdotNet).

Those two things made me realize we had a lot of work to do in Portland around building a better user group and more importantly a better community. I realized I (and the group as a whole) needed to look forward to lightning talk nights. It’s on these nights when a first time speaker gets up and fumbles through a rushed presentation of a small idea that our user group truly grows. And it’s after the “official” meeting when we reconvene at the local pub that our community grows in other equally important ways.

Because of that revelation I have decided to appoint myself Community Booster. I am going to do my best to encourage involvement at every level. I’m going to encourage people to attend the user group meetings, to come out with us after, to speak at the lightning talks, to submit talks to both CBNUG and code camps. This isn’t an area I have much experience in, and I’m sure I’ll make some mistakes along the way, but I feel like the community I want to have in my local area needs someone (or multiple people) to really embrace this role.

Don't Be Late for Scrum

Jeremy Hutchinson — Tue, 03 Feb 2015 00:00:00 UTC

We all know the importance of being on time for meetings, and since scrum is designed to be a short meeting, if you’re 5 minutes late for scrum you can miss a third to half of it.

I’m a morning person, so I find myself most focused and most productive before lunch. That often means that when scrum rolls around at 9:30 I can be totally lost in thought with no concept of time. In other words I have a tendency towards running late. The obvious thing to do is to set a reminder, but I usually run my sound through my headphones so if I’m not wearing them there’s a good chance that reminder is just going to pop up and not be seen. When I worked in an office I’d see the other developers moving out of the corner of my eye and realize what time it was, no problem.

Since I’ve been working from home we’ve been having scrum over Skype. Our leader starts a group call and thanks to Skype’s ability to ring through the speakers while using my headset for communication I was never late.

That worked great, but we recently moved our scrums to a Google Hangout. On the plus side, we’re all doing video (not sure why we didn’t with Skype) and having a blast with Google Effects. The downside of course is that we need to “dial-in” to every day.

I realized immediately that this left me with the potential to be late or even miss scrum, here’s the solution I came up with. I’m using Task Schedule that is built into Windows to launch Chrome and navigate to our Scrum hangout. Just create a Basic Task, set the schedule, choose Launch a Program for Action. Select the path to your favorite browser for the Program, and put the URL in the Add arguments field.

Now every morning when scrum starts Chrome opens a new tab and brings up the Scrum hangout. All I need to do is click the “Join” button.

New Years Resolutions 2015

Jeremy Hutchinson — Tue, 13 Jan 2015 00:00:00 UTC

This is my annual post where I publicly declare a few goals for the coming year. Next year around this time I will take a look back to see how I did. Looking back at last year I noticed that some of my resolutions didn’t have objective measurements, so I’m trying to include those this year.

Speak More

They say you really learn something when teaching it, and I can speaking forced me to deeply learn the topics I was presenting. I really enjoyed speaking at my local .Net user’s group as well as Boston Code Camp and Vermont Code Camp. I’m going to submit sessions to all both code camps, my local user group and at least 2 larger conferences. All I can do is submit, the decision about whether I speak is out of my hands.

Blog More Consistently

Last year I resolved to blog more, which I did, but I had long stretches without any new posts. This year I’ve been receiving John Sonmez’s email course on building a blog. It’s been an excellent course, and I would highly recommend signing up. One of the steps in the course is to commit to a blogging schedule. I’m committing to 2 posts per month. A much more objective goal than I had last year. Don’t be surprised if you see 2 posts on the last day of every month :)

Finish My Side Project

A friend and I have been working on a rental property management web application for a while now. We both started new jobs in the middle of it and we’re both burnt out to the point that we were close to ditching it. We are down to a handful of tough bugs and a few minor features we want to implement before releasing. We’ve been on a hiatus for a month now, I’m thinking I’ll take another month hiatus before picking it back up, but I will release it by May 1, 2015 with bugs and missing features if I have to.

Personal Goals

Lose Weight - As I said last year, this one is a bit cliche for a New Year’s resolution, and last year wasn’t a grand success. I only lost 5 of the 40 I figured I needed to lose. This year I’m going to target losing 20 of the remaining 35. I’ll tackle the rest in 2016.

Finish House Projects - I have projects that I started basically as soon as I bought this house 5+ years ago that still haven’t been completed. These are things I can do myself and I have been loath to hire them out. I’m either going to do them myself or hire them out this year:

Fix the hole in the kitchen ceiling
Sheetrock the attic
Finish the trim on the second floor
Remove the unused oil tank in the basement
Paint the house

New Years Resolutions 2014 - Retrospective

Jeremy Hutchinson — Mon, 12 Jan 2015 00:00:00 UTC

It’s time for my annual resolutions blog post, but first I wanted to do a little retrospective to see how I did on last year’s resolutions.

✓ Blog More - I did blogged more, but not as much as I had hoped. Posts were still less than once per month.

✓ Find more ways to share knowledge - My talk at my local user group went well enough that I submitted and gave talks at the June Boston Code Camp, the Vermont Code Camp, and November Boston Code Camp. I really enjoyed it, and I’m definitely going to continue. I tried submitting talks to some bigger conferences but was not accepted. I’ll keep trying.

X Networking - I got off to a good start, checking in with some people I hadn’t spoken to in a while to see what they were up to, but I didn’t continue it and I didn’t really do anything to expand my network aside from chatting with some people at the code camps.

✓ Going to Bed Earlier - I mostly nailed this one.

X Lose weight - I did shed 5 pounds, and if I didn’t change anything I think I’d lose another 5 this next year.

So I was 3 for 5 last year. I would list the year as a success overall. I made progress, and I’m still heading in the right direction.

Sharing Code with Dependency Injection

Jeremy Hutchinson — Tue, 28 Oct 2014 00:00:00 UTC

This is a multipart series on how to share code between .Net platforms. All the examples will be showing how to share between Windows 8 Store applications and Windows Phone 8 application, but the techniques are useful for sharing code between any .Net/Xamarin platforms.

What is Dependency Injection?

Dependency Injection is a form of inversion of control where the consumer of a service passes some of the objects on which that service is dependent to the service, rather than having the service create them.

How do I do it?

In this case we’re not going to use a Dependency Injection framework, we’re going to use what I call “the poor mans dependency injection”. I’m doing it this way to keep it simple and this could still work well with a framework.

First we’re going to create a Portable Class Library and in that library we’re going to define an interface for our data storage methods

public interface IMyStorage
{
    void Save(string key, object value);
    object Get(string key);
}

The we’re going to move our MainePageViewModel class to that library. We need to modify that class to accept an IMyStorage in it’s constructor, then use that object to get and save it’s data.

public class MainPageViewModel : INotifyPropertyChanged
{
    private IMyStorage _myStorage;
    public MainPageViewModel(IMyStorage myStorage)
    {
        _myStorage = myStorage;
    }

    private string _helloMessage = "Hello World";
    public string HelloMessage
    {
        get { return _helloMessage; }
        set
        {
                
            if (_helloMessage != value)
            {
                _helloMessage = value;
                RaisePropertyChanged("HelloMessage");
            }
        }
    }

    private string _name = "";
    public string Name
    {
        get { return _name; }
        set
        {
            if (_name != value)
            {
                _name = value;
                RaisePropertyChanged("Name");
            }
        }
    }

    public ICommand SaveAction { get { return new RelayCommand(() =&gt; Save()); } }

    public ICommand LoadAction { get { return new RelayCommand(() =&gt; Load()); } }

    private void Load()
    {
        object name = null;

        name = _myStorage.Get("Name");

        if (name != null)
        {
            HelloMessage = "Load " + name.ToString();
        }
    }

    private void Save()
    {
        _myStorage.Save("Name", Name);

        HelloMessage = "Save " + Name;
    }

    private void RaisePropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

In the platform specific projects we need to add a reference to the PCL and create a class that implements IMyStorage. Windows Phone specific code below

class MyStorage : IMyStorage
{
    public void Save(string key, object value)
    {
        if (IsolatedStorageSettings.ApplicationSettings.Contains(key))
        {
            IsolatedStorageSettings.ApplicationSettings[key] = value;
        }
        else
        {
            IsolatedStorageSettings.ApplicationSettings.Add(key, value);
        }
    }

    public object Get(string key)
    {
        if (IsolatedStorageSettings.ApplicationSettings.Contains(key))
        {
            return IsolatedStorageSettings.ApplicationSettings[key];
        }
        return null;
    }
}

Then in the MainPage.xaml.cs where we are setting the page’s datacontext to the MainPageViewModel, we need to make sure we’re passing a new instance of the MyStorage class (this is the actual Dependency Injection, poor man’s style)

private void PhoneApplicationPage_Loaded(object sender, RoutedEventArgs e)
{
    this.DataContext = new MainPageViewModel(new MyStorage());
}

Sharing Code with Inheritance

Jeremy Hutchinson — Tue, 14 Oct 2014 00:00:00 UTC

What is Inheritance?

I’m just going to go ahead and assume you understand inheritance, but I’m keeping this section to stay with the theme from the other posts in this series.

How do I do it?

To share code in this way we’re going to create an abstract class MainViewModelBase with an abstract method defined for the place where we’re going to do our platform specific coding. We can share that class between projects either through file linking or creating a Portable Class Library

abstract class MainPageViewModelBase : INotifyPropertyChanged
{
    protected abstract void Load();
    protected abstract void Save();

    //The rest of the common code would go here
    private string _helloMessage = "Hello World";
    public string HelloMessage
    {
        get { return _helloMessage; }
        set
        {
            if (_helloMessage != value)
            {
                _helloMessage = value;
                RaisePropertyChanged("HelloMessage");
            }
        }
    }

    private string _name = "";
    public string Name
    {
        get { return _name; }
        set
        {
            if (_name != value)
            {
                _name = value;
                RaisePropertyChanged("Name");
            }
        }
    }

    public ICommand SaveAction { get { return new RelayCommand(() =&gt; Save()); } }

    public ICommand LoadAction { get { return new RelayCommand(() =&gt; Load()); } }

    

    private void RaisePropertyChanged(string propertyName)
    {
        if (PropertyChanged != null)
        {
            PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
        }
    }

    public event PropertyChangedEventHandler PropertyChanged;        
}

Then we’re going to inherit from that class in each of our projects. Here’s what the code for the Windows Phone project looks like

class MainPageViewModel : MainPageViewModelBase
{
    protected override void Load()
    {
        object name = null;
        if (IsolatedStorageSettings.ApplicationSettings.Contains("Name"))
        {
            name = IsolatedStorageSettings.ApplicationSettings["Name"];
        }
        if (name != null)
        {
            HelloMessage = "Hello " + name.ToString();
        }
    }

    protected override void Save()
    {
        if (IsolatedStorageSettings.ApplicationSettings.Contains("Name"))
        {
            IsolatedStorageSettings.ApplicationSettings["Name"] = Name;
        }
        else
        {
            IsolatedStorageSettings.ApplicationSettings.Add("Name", Name);
        }
        HelloMessage = "Hello " + Name;
    }
}

Sharing Code with Partial Classes

Jeremy Hutchinson — Wed, 01 Oct 2014 00:00:00 UTC

What are Partial Classes?

Partial Classes are a way to split a class up into multiple files. It is frequently used when one part of your class is generated code and another part is written by hand. In this case we’ll use partial classes to separate code that is shared between platforms and code that is platform specific.

How do I do it?

First you would need to use linked files to share the code between your projects. Then you need to change the class declaration to include the keyword partial.

partial class MainPageViewModel

Then you create a new files in each of your projects. In this example we’ll create MainPageViewModel.WP8.cs and MainPageViewModel.W8.cs. The WP8 file would be created in the Windows Phone project and the W8 file would be created in the Window 8 project. We then need to include that same class declaration in those files.

Then we just move the methods with platform specific code into those platform specific partial classes.

The WP8 file would look like this:

partial class MainPageViewModel
{
    private void Load()
    {
        object name = null;
        if (IsolatedStorageSettings.ApplicationSettings.Contains("Name"))
        {
            name = IsolatedStorageSettings.ApplicationSettings["Name"];
        }
        if (name != null)
        {
            HelloMessage = "Load " + name.ToString();
        }
    }
}

The W8 file would look like this:

partial class MainPageViewModel
{
    private void Load()
    {
        object name = null;
        if (ApplicationData.Current.LocalSettings.Values.ContainsKey("Name"))
        {
            name = ApplicationData.Current.LocalSettings.Values["Name"];
        }

        if (name != null)
        {
            HelloMessage = "Hello " + name.ToString();
        }
    }
}

Sharing Code with Conditional Compilation

Jeremy Hutchinson — Wed, 27 Aug 2014 00:00:00 UTC

What is Conditional Compilation?

Conditional Compilation tells the compiler to selectively compile code. Many developers use these to run certain code only while in debug that they don’t want to run in production.

#if DEBUG
    //do some stuff
#endif

How do I do it?

The first step would be to link a file between two projects. Then you can either use an existing Conditional Compilation Symbol or create your own. For example Windows Phone 8 defines SILVERLIGHT and WINDOWS_PHONE as Conditional Compilation Symbols. You see see what symbols have been defined by your project and even add your own by going to the Build tab in Project Properties.

To use the Conditional Compilation Symbols you just use the #if statement. For example if you are using a namespace exists in Windows Phone, but doesn’t exist in Windows 8 you could do this:

#if WINDOWS_PHONE
    using System.IO.IsolatedStorage;
#else
    using Windows.Storage;
#endif

The System.IO.IsolatedStorage using statement will only be compiled in the Windows Phone projects. The Windows.Storage using statement will be compiled in all other projects.

Sharing Code with Linked Files

Jeremy Hutchinson — Fri, 15 Aug 2014 00:00:00 UTC

What are Linked Files?

Linked files are a way for two or more projects to both reference the same file. One project generally keeps that file under it’s file structure, other projects reference the file there. You can open the file from any of the projects as you normally would and edit it. All changes are saved to the one file.

Be Aware

You need to manually link the files. If you have 50 code files you want to share between project, you need to add those 50 files as links individually.
If you rename a file that has been shared, you need to delete the old link and add the new link.

How do I do it?

Go through the regular process for adding an existing file, but after you’ve selected the file you need to select “Add as Link” from the dropdown at the bottom.

Automating the compare of 2 rows in a trigger

Jeremy Hutchinson — Tue, 06 May 2014 00:00:00 UTC

I just answered this question on StackOverflow about how to generically compare an inserted row to a deleted row within a trigger. I started by just commenting that it would be a good place to do a little code generation, but something about the problem wouldn’t let me put it down. Here’s what I came up with.

First I created a function that would return the query that would actually do the comparison. Notice that I’m comparing #inserted and #deleted rather than inserted and deleted. This is because we don’t have access to the inserted and deleted tables when we’re running the comparison query in an exec()

create function GetChangedRowsQuery(
	@TableName				varchar(50), 
	@PrimaryKeyColumnName	varchar(50),
	@RowVersionColumnName	varchar(50) = ''
)
returns varchar(max)
as
begin
	
    declare 
	@ColumnName varchar(50),
	@GetChangedRowsQuery varchar(max)

    select @GetChangedRowsQuery = 
           'select isnull(a.' + @PrimaryKeyColumnName + ', b.' 
           + @PrimaryKeyColumnName + ') 
      from #inserted a
      full join #deleted b 
        on a.' + @PrimaryKeyColumnName + ' 
           = b.' + @PrimaryKeyColumnName + '
     where '

    declare ColumnCursor cursor Read_Only
    for select Name
          from Sys.columns
         where object_id = Object_Id('Member')

    open ColumnCursor
    fetch next from ColumnCursor into @ColumnName
    while @@FETCH_STATUS = 0
      begin
	if (@ColumnName != @PrimaryKeyColumnName 
            and @ColumnName != @RowVersionColumnName)
	  begin
            select @GetChangedRowsQuery = @GetChangedRowsQuery 
                + '((a.' + @ColumnName + ' != b.' + @ColumnName 
                + ' or a.' + @ColumnName + ' is null 
                    or b.' + @ColumnName + ' is null) 
                and (a.' + @ColumnName + ' is not null 
                     or b.' + @ColumnName + ' is not null))' 
                + char(13) + '      or ' 
          end
        fetch next from ColumnCursor into @ColumnName
      end
    close ColumnCursor
    deallocate ColumnCursor

    select @GetChangedRowsQuery 
           = substring(@GetChangedRowsQuery, 0, len(@GetChangedRowsQuery) -7)

    return @GetChangedRowsQuery
end

Next, I created a trigger. It creates the #inserted and #deleted temp tables, get’s the query from the function, creates a temp table to hold the results. Then it inserts the result into the temp table. I’m just selecting the top 10 changed rows, but you could do whatever you needed to do with the changed rows at this point.

create trigger TestTrigger on Member for Insert, Update, Delete
as
begin
	
    select *
      into #Inserted
      from Inserted

    select *
      into #Deleted
      from Deleted

    declare @GetChangedRowsQuery varchar(max)

    select @GetChangedRowsQuery 
            = dbo.GetChangedRowsQuery('MemberTrash', 'MemberId', '')

    create table #Temp (PrimaryKey int)

    insert into #Temp (PrimaryKey)
    exec (@GetChangedRowsQuery) 

    select top 10 *
      from #Temp

    drop table #Temp
    drop table #Inserted
    drop table #Deleted
end

Unsubscribe from everything

Jeremy Hutchinson — Fri, 02 May 2014 00:00:00 UTC

I recently moved my email from Gmail to Outlook.com. It’s not a small deal. I needed to get all my friends and family to update their contact info for me, and I’ve had to update my contact info on countless sites. As part this move I also started unsubscribing to pretty much anything that came into my Gmail account, but not signing up to receive those emails in my Outlook.com account.

The results have been wonderful. After about 2 weeks, I now only receive 1-2 emails a day, mostly from people I want to get emails from. I don’t really know how many emails I was receiving before, but I can tell you it’s really refreshing to be receiving so few.

I’ve added a reminder to my calendar for next year to spend a week or two unsubscribing from all the junk that builds up as I try out various new services. You should do the same.

AngularJS URLs missing trailing slash

Jeremy Hutchinson — Fri, 14 Mar 2014 00:00:00 UTC

I ran across this problem trying to deploy an Asp.Net MVC website with an AngularJS front end. Everything worked fine as long as the site was deployed as it’s own website within IIS, but when we deployed to an Application folder within an existing site things started going wrong.

The problem was that the URLs were not getting their trailing slashes properly. IIS adds a trailing slash to URLs when the last segment of the address refers to a folder rather than a file.

http://somesite.com/AngularApp should have been converted to http://somesite.com/AngularApp/

Since it wasn’t getting converted I was getting http://somesite.com/AngularApp#/ rather than http://somesite.com/AngularApp/#/

The fix I settled on was to check the URL of the request when it came in and if it matched the root url, but didn’t have the trailing slash, add the trailing slash. I just added the following code to the Global.asax

protected void Application_BeginRequest()
{
    if (Request.ApplicationPath != "/" 
            && Request.ApplicationPath.Equals(Request.Path, StringComparison.CurrentCultureIgnoreCase))
    {
        var redirectUrl = VirtualPathUtility.AppendTrailingSlash(Request.ApplicationPath);
        Response.RedirectPermanent(redirectUrl);
    }
}

Show File Extension in Sharepoint Document Library

Jeremy Hutchinson — Tue, 21 Jan 2014 00:00:00 UTC

I was recently tasked with changing the view in our TFS Project Portal’s document library to show the file extension so you knew whether you were opening a PDF, Word Document, PowerPoint or something else for which you might not have the software installed. There is an easy way and a hard way, and the guidance I received from a few Google searches skipped a few steps on the hard way.

Easy Way

Open the Document Library
Click on the Library Tools -> Library tab at the top
Scroll to the bottom and click the view you wish to change
Check "Name used in forms" column

This adds a new column with the full file name and extension, but it’s not clickable to view the document, so you end up with two columns for document name, the name and the name with extension. This is why I ended up going down the hard way.

Hard Way

Open the site in SharePoint Designer
Click Lists and Libraries and open the Document Library you want to modify
Open the View you want to modify
Right click on the first row in the Name column and select Insert Formula
In the Edit XPath expression box enter something that is easily searchable ie. xxxxxxxx
Click OK
Switch to the Code View
Search for your xxxxxxx and delete the element it created
Right above or below that should be an element like so <xsl:value-of select="$thisNode/@FileLeafRef.Name" />
Replace that with <xsl:value-of select="$thisNode/@FileLeafRef.Name" /><xsl:if test="$thisNode/@FileLeafRef.Suffix!=''">.<xsl:value-of select="$thisNode/@FileLeafRef.Suffix" /></xsl:if>
Save, exit and you're done

The examples I found online left out steps 4-8, and until I did those the <xsl:value-of select=”$thisNode/@FileLeafRef.Name” /> element didn’t exist.

New Year's Resolutions 2014

Jeremy Hutchinson — Mon, 06 Jan 2014 00:00:00 UTC

Here’s my list of New Year’s Resolutions for 2014:

Blog More

Historically, I only wrote technical posts whenever I came across something really novel and wasn’t so specific that I didn’t think anyone else can use it. This year I’m going to loosen my standards for a technical blog posts. That means there should be more posts, but some of them might just be a different spin on things that others have covered, or things that are really specific and may not be as useful to a broad audience.

Find more ways to share knowledge

For most of last year I shared an office with a very green developer. Helping him learn the ropes has also been a great learning experience for myself. Having to explain some concepts I take for granted to a beginner stretched me in ways I didn’t know I needed to be stretched. I’d like to explore other ways to share what I have learned. I have already volunteered to do a short talk on T4 at my local users group (after the main talk), hopefully I’ll be invited back after that. I’m also going to keep a lookout local volunteer opportunities for things like Hour of Code

Networking

I’ve worked with and met a lot of great people, but many of them I haven’t spoken with in years. My goal is to reach out to someone twice a week either through email or phone.

Personal Stuff

I also have a few resolutions on a more personal level:

Go to bed earlier - I’m an early riser by nature, and every thing in life is easier when I’m well rested

Lose weight - It’s the cliche New Year’s resolution I know, but I lost a bunch of weight before my youngest son was born last April and have packed on the pounds since then. I make bad food related decision when I’m tired and a new baby isn’t anything if it isn’t tiring. I’d like to lose 40 pounds and keep it off for good. No crazy diet here, more of a lifestyle change. Just eating a little less and working out a little more. I should be able to lose all of that weight by the end of 2014.

Error: The Key is Already Attached from Breeze.js

Jeremy Hutchinson — Sat, 30 Nov 2013 00:00:00 UTC

First let me say if you’re reading this and you haven’t checked out Breeze.js, you should. It’s a nice little library. I’m using it in an Angular.js based application and it has greatly simplified data access. Now on to the show.

I’m using Breeze.js for data access and as part of that I am registering some constructors like so.

var AddressCtor = function () {
    this.CompanyId = document.getElementById('CompanyId').value;
};

var NoteCtor = function () {
    this.CompanyId = document.getElementById('CompanyId').value;
};

metadataStore.registerEntityTypeCtor('Address', AddressCtor);
metadataStore.registerEntityTypeCtor('Note', NoteCtor);

Everything was working fine then I tried to do a little code cleanup. The constructors for Note and Address were identical. So, of course I, re-factored them into a single generically named function.

var CompanyEntity = function () {
    this.CompanyId = document.getElementById('CompanyId').value;
};

metadataStore.registerEntityTypeCtor('Address', CompanyEntity);
metadataStore.registerEntityTypeCtor('Note', CompanyEntity);

Well, it appears that you cannot register 2 constructors that call the same function like that. If you do you the error “The Key is Already Attached: Note:Webapplication1”, and no data loaded in the Angular app.

When I finally found the cause, I couldn’t believe it. The fix that I came up with was to pass null as the constructor parameter and move that CompanyId assignment into a function that is passed as the init parameter. This has the added bonus that entities that need to do a series of things AND set the CompanyId can just call the companyEntityInit function from inside their initializers.

function companyEntityInit(entity) {
    entity.CompanyId = document.getElementById('CompanyId').value;
};

metadataStore.registerEntityTypeCtor('Address', null, companyEntityInit);
metadataStore.registerEntityTypeCtor('Note', null, companyEntityInit);

Burned by Ternary Operators

Jeremy Hutchinson — Mon, 16 Sep 2013 00:00:00 UTC

First let me say that I’m not a fan of ternary operators. I try to avoid them because I feel that an explicit if/else is much more readable. I do use them on occasion and this seemed like the perfect place for them.

I ran into a interesting problem while trying to get a Linq where clause to work with ternary operators. In hindsight the problem is pretty obvious, but it stumped me and one of my coworkers for a few minutes. It wasn’t until we solved the problem in a different way that I realized what I had initially missed.

First the setup:

var books = new List<Book>();
books.Add(new Book { Title = "To Kill a Mockingbird", Description = null });
books.Add(new Book { Title = "Catcher in the Rye", Description = null });

There where clause I was building was part of some basic search functionality. It would take a passed in value and check to see if the Title or the Description contained that value:

var qry = books.Where(u =>;
        u.Description == null ? false : u.Description.ToUpper().Contains(searchStr)
        || u.Title == null ? false : u.Title.ToUpper().Contains(searchStr)
        );

Attempts to search for the letter T were returning no results. Like I said, I struggled with it, called in a second set of eyes and they couldn’t see the problem. We then re-wrote where clause like this:

var qry = books.Where(u =>;
        (u.Description != null &amp;&amp; u.Description.ToUpper().Contains(searchStr))
        || (u.Title != null &amp;&amp; u.Title.ToUpper().Contains(searchStr))
        );

This returned 2 results as expected. After a bit of rumination I realized the problem was my lack of parentheses. I thought I had written this:

var qry = books.Where(u =>;
        (u.Description == null ? false : u.Description.ToUpper().Contains(searchStr))
        || (u.Title == null ? false : u.Title.ToUpper().Contains(searchStr))
        );

When I had essentially written this:

var qry = books.Where(u =>
        u.Description == null ? false : 
                (
                u.Description.ToUpper().Contains(searchStr)
                || u.Title == null ? false : u.Title.ToUpper().Contains(searchStr)
                )
        );

This was clearly just my misunderstanding of how ternary operators are interpreted, and I’m unlikely to ever forget this, but I’m also going to continue to avoid ternary operators wherever I can and encourage others to do the same.

Repository Pattern with Entity Framework

Jeremy Hutchinson — Tue, 10 Sep 2013 00:00:00 UTC

I’m currently working on a little side project using ASP.Net MVC and Entity Framework, so of course my urls looks something like http://mysite.com/orders/14 to pull up the order that has OrderId 14. The problem of course is security, I need to ensure that users can only view their own orders.

My first pass at managing this was to just add the UserId to the where clause of a LINQ query.

dbContext.Orders.FirstOrDefault(x => x.Id == OrderId && x.UserId == userId);

This obviously works, but leaves me open making mistakes down the road by either forgetting to add that to the where clause, or on a more complex where clause having the UserId portion not working in one of the Or branches. My first thought was of course to add some unit tests to the controller actions to account for this, but when I thought about doing that I realized I would essentially be writing the same test for every action.

I decided I needed to move the responsibility for adding the UserId to the where clause to a central location that handled that for all calls to user specific entities. I could then write unit tests that code once and rest assured that all my controller actions were covered for that case.

My solution involved putting a generic repository layer on top of Entity Framework that was able to both.

First I defined the repository interface:

public interface IRepository<T>
{
    T GetById(int id);
    IQueryable<T> GetAll();
    void Add(T entity);
    void Update(T entity);
    void Delete(int id);
    void Delete(T entity);
}

And an interface that all user specific entities must implement

public interface IUserEntity
{
    int Id { get; set; } 
    int UserId { get; set; }
}

Then the repository itself with methods for all CRUD operations. You’ll notice that each operation checks to ensure that the UserId of the entity affected matches the UserId that was used to create the repository:

public class UserRepository<T> : IRepository<T> where T : class, IUserEntity
{
    private readonly int _userId;

    public UserRepository(DbContext dbContext, int userId)
    {
        _userId = userId;
        if (dbContext == null)
        {
            throw new ArgumentNullException("dbContext");
        }
        DbContext = dbContext;
        DbSet = DbContext.Set<T>();
    }

    protected DbContext DbContext { get; set; }

    protected DbSet<T> DbSet { get; set; }

    public virtual IQueryable<T> GetAll()
    {
        return DbSet.Where(x => x.UserId == _userId);
    }

    public virtual T GetById(int id)
    {
        var entity = DbSet.FirstOrDefault(x => x.Id == id && x.UserId == _userId);
        return entity;
    }

    public virtual void Add(T entity)
    {
        entity.UserId = _userId;
        DbEntityEntry dbEntityEntry = DbContext.Entry(entity);
        if (dbEntityEntry.State != EntityState.Detached)
        {
            dbEntityEntry.State = EntityState.Added;
        }
        else
        {
            DbSet.Add(entity);
        }
    }

    public virtual void Update(T entity)
    {
        if (entity.UserId != _userId)
        {
            return;
        }

        DbEntityEntry dbEntityEntry = DbContext.Entry(entity);
        if (dbEntityEntry.State == EntityState.Detached)
        {
            DbSet.Attach(entity);
        }
        dbEntityEntry.State = EntityState.Modified;
    }

    public virtual void Delete(T entity)
    {
        if (entity.UserId != _userId)
        {
            return;
        }

        DbEntityEntry dbEntityEntry = DbContext.Entry(entity);
        if (dbEntityEntry.State != EntityState.Deleted)
        {
            dbEntityEntry.State = EntityState.Deleted;
        }
        else
        {
            DbSet.Attach(entity);
            DbSet.Remove(entity);
        }
    }

    public virtual void Delete(int id)
    {
        var entity = GetById(id);
        if (entity == null) return; // not found; assume already deleted.

        if (entity.UserId != _userId)
        {
            return;
        }
        Delete(entity);
    }
}

Next we wrap all of those repositories up in a Unit of Work pattern, (sample code only shows one repository, my production code has all my repositories in one UOW class).

public class UoW : IDisposable
{
    private readonly int _userId;
    private MyDbContext DbContext { get; set; }

    public UoW(int userId)
    {
        _userId = userId;
        DbContext = new MyDbContext();
    }

    private IRepository<Order> _orders;
    public IRepository<Order> Orders
    {
        get
        {
            if (_orders == null)
            {
                _orders = new UserRepository<Order>(DbContext, _userId);
            }
            return _orders;
        }
    }

    public void Dispose()
    {
        if (DbContext != null)
        {
            DbContext.Dispose();
        }
    }
}

Now when we want all of the Order 14, we create an instance of the Unit Of Work class for the current user and request Order 14.

var uow = new UoW(123);
uow.Orders.GetById(14);

And if someone types http://mysite.com/orders/14 into the address bar, they won’t get back any data if their UserId doesn’t match the UserId for Order 14.

It’s still not very testable, but all it takes is adding another constructor to allow us to pass in the DBContext:

public UoW(int userId, MyDbContext dbContext)
{
    _userId = userId;
    DbContext = dbContext;
}

Now we can use any DBContext we like for testing. I’m using Effort - Entity Framework Unit Testing Tool to create an in memory database context for testing purposes. It’s fast and simple to use.

I'm Back

Jeremy Hutchinson — Tue, 20 Aug 2013 00:00:00 UTC

After a long hiatus I'm going to start blogging again.

"Where have you been?" you might ask. Well, I've had a few big changes in my life this past year.

First, I took a new job at Winxnet, a software consulting and IT management company based in Portland, Maine. It's been a big switch. The first contract I was assigned to was an enormous SharePoint project. Being a WPF developer, the switch to web development really stretched me, and the Sharepoint part was just an extra wrench thrown in the works. I was learning a lot of things that most web and/or SharePoint developers would probably consider pretty basic. It's always fun getting stretched like that, but it left no time or energy for blogging.

Second, in April my second child was born. Anyone with kids knows that I get a free pass for a few months for that, no questions asked.

Third, I've started another side project (no public details yet). This has eaten up a bunch of time the last couple of months, but it has also got my gears turning with ideas for blog posts.

Oh, and one more thing. My install of Wordpress died. I can no longer log into the admin account. Rather than spend the time trying to solve the underlying issue I thought I'd check some other CMSs. I'll be migrating my old posts over the next week, then I'll actually create a few new techy posts.

New Keyboard Layout Progress Update

Jeremy Hutchinson — Thu, 18 Oct 2012 00:00:00 UTC

Back in June I decided to change my keyboard layout with the hopes of increasing my typing speed. I have touch typed for 20 years on a QWERTY keyboard and was getting about 54 words per minute. First I tries Dvorak layout, but had a tough time even learning the keyboard never mind typing with any speed. Then I switched to the Colemak layout which I was able to get some speed on very quickly.

I’m currently typing at 60 words a minute. That’s a 10% improvement, and I’m sure there is still some speed left to be gained, but I’m not sure I’ll ever make it to my original goal of doubling my typing speed. That would be 108 WPM, and at this point I’d be thrilled with 80 WPM.

If I could go back, I’m not sure if I would switch again. More speed was my original goal, and I think I could have increased my speed faster if I had done as much practice with QWERTY as I have done with Colemak. But here I am, I have switched and I don’t think I’ll be going back.

The Colemak layout is noticeably easier to type on. Much less reaching for common letters (I’m looking at you E, R and T). My typing hasn’t suffered too terribly on QWERTY keyboards, but I can no longer touch type, I have to watch the keyboard.

Up next on my experiments with typing, mechanical keyboards. I have noticed in my practicing that there are times when I’m not sure whether I have typed a letter or not because of the mushy keys. I’ll monitor my WPM before and after that switch when I finally fork over the money for a >$100 keyboard.

Career Goals

Jeremy Hutchinson — Wed, 26 Sep 2012 00:00:00 UTC

I’ve had a few people ask me over the last few weeks what my long term career goals are. The first time someone asked me, it caught me a little off guard. It’s not a question I get asked a lot, and it’s not something I’ve really given any thought to in the last few years. My answer was that I didn’t have any career goals, that I was happy doing what I was doing.

####So, do I really not have any career goals?

The more times I was asked about my career goals the more I became embarrassed by my answer. Why didn’t I have any career goals? Shouldn’t I have a goal? Without a goal aren’t I just drifting through life? Then it finally occurred to me, I do have a career goal. It just doesn’t involve moving up the corporate ladder. Or down, or across.

My goals* are:

Continue writing code
Continue learning and improving
Continue working with current technology

If I stop with #2, then I’ve failed at #3 and should probably stop with #1 for the sake of anyone who might have to maintain my code.

*I know these are not great goals as they are not measurable, but that’s as close as I can get to good goals for my career. If you have suggestions for how I might clarify them please leave a comment.

Why I hate performing in front of friends and family*

Jeremy Hutchinson — Tue, 28 Aug 2012 00:00:00 UTC

*Not a technical blog, you’ve been warned.

Over this last weekend we had our neighborhood block party. This year, my contribution was to plan the live music portion of the event. For this I was able to get 2 solo acts and a 3 piece band to commit to playing for "all the hot dogs they could eat."

In the end one of the solo acts and the band couldn’t make it due to family emergencies. To fill the gap I decided I’d play a few tunes even though I previously decided to leave myself out of the show. I told myself it was because I hadn’t been practicing for a year of so, but there was more to it.

I enjoy playing music. I like going down to an open mic with some friends and belting out a couple of tunes, and I always had fun performing in the band I was in a few years back, but I was really dreading playing music for my neighbors. It wasn’t the crowd, and it wasn’t my neighbors friends, it was my neighbors that I didn’t want to play in front of.

It’s not that my neighbors are judgmental, mean, or anything like that. Quite the opposite, they are all great people and I knew the would be supportive even if I bombed. I couldn’t ask for better neighbors.

So why did I dread playing for them when I was perfectly comfortable going into a bar and playing for a bunch of strangers who always left an awkward silence where the polite applause are supposed to go?

There’s 3 reasons I hate playing for friends and family:

I respect their opinions. If I didn’t respect their opinions, they wouldn’t really be my friends would they.
I don’t really trust their compliments. I know that if I bomb they probably won’t tell me, they’ll focus on the positive unless I press them for an honest opinion. I did that once, it confirmed what I already knew but it really sucked to hear it from someone I respected.
I’m going to see them again and again and again. The nature of strangers is that you rarely, if ever, see them again.

So there it is, that’s why I hate performing for friends and family.

Keyboard Layout Comparison

Jeremy Hutchinson — Tue, 17 Jul 2012 00:00:00 UTC

For the past few weeks I’ve experimented with alternate keyboard layouts with the long-term goal of increasing my typing speed.

At first I tried Dvorak, which is the most popular alternative layout. I found it cumbersome to learn. Almost every key is in a new position. After a couple of weeks of practice I had mostly memorized the layout, but was still only typing at 16 WPM.

Then, while clearing out some bookmarks I found a link to the Colemak layout. I’ve considered switching layouts for some time, so I wasn’t surprised to find the bookmark. Like Dvorak, Colemak is designed for efficient and ergonomic touch typing in English. Unlike Dvorak, it is based somewhat on the QWERTY keyboard. Only 17 keys have moved. The transition was easy. I memorized the new layout in just a couple of days and was typing at 30+ WPM within a week. I seem to have stalled, but I think the issue now is learning to type words (or letter combos) instead of typing letter by letter. That’s something I expect will come with time.

Here are my observation of the learning process:

There is a noticeable difference in how much finger movement is required compared with QWERTY. I hope this difference will result in more speed and comfort in the long run.
I had no problems switching between layouts until I was above 25 WPM on Colemak, then I started to get confused when on QWERTY. I switched to Colemak completely after I hit 30 WPM 2 days later.
My speed at a typing test seemed slower than regular typing when I tested on QWERTY, but I definitely copy text faster in Colemak than I type my own thoughts. This has improved since switching to Colemak full-time.
TypeRacer is a great place to practice. You race others in short (<2 minute) races, and the quotes you type are at least somewhat interesting. It also tracks and graphs your progress.
Slow and accurate beats fast and inaccurate. If you mistype, it takes 3 strokes to make a letter. At 30 WPM you type 2.5 characters per second. You are better off spending the time to type the right letter the first time.
I don’t type as much as I thought. With Visual Studio’s Intellisense I only type 1 or 2 letter then press Tab to complete for most things. I honestly thought I typed more.

A really cool tool for comparing keyboard layouts. It calculates the distance traveled, percentage home row and some other stats to help illuminate the differences between layouts.

Stats for this post (except the grid):

	QWERTY	Colemak	Dvorak
Distance	74.50m	38.16m	44.29m
Same Hand	38.25%	32.45%	22.16%
Same Finger	5.0%	1.333%	3.291%
Top Row	52.70%	18.45%	24.95%
Home Row	28.86%	65.20%	61.07%
Bottom Row	15.87%	11.91%	9.666%

QWERTY is a clear loser here, its primary advantage is its monopoly. The relative merits of Dvorak vs Colemak are debatable. Are Colemak’s higher home row percentage and lower same finger percentage worth the trade for higher same hand and bottom row percentage? Colemaks biggest advantage over Dvorak is the ease of learning if you are already proficient with QWERTY.

Changing Keyboard Layouts

Jeremy Hutchinson — Tue, 12 Jun 2012 00:00:00 UTC

In my last post I set a goal to switch to the Dvorak layout over the next few months and I’m looking to double my typing speed. To do that, I am practicing typing on the Dvorak layout for a 10-15 minutes a day for a while and as my speed improves I’ll add time. I’ve found that switching layouts is startlingly easy, so I thought I’d share how to do it (instructions are for Windows 7 and may vary for other versions).

Click Start and type “intl.cpl” into the search box. This will bring up the Region and Language control panel. Click on the Keyboards and Languages tab.

Click Change Keyboards

Click Add and select the keyboards you want to add. I just added United States-Dvorak.

Go to the Advanced Key Settings

From here you can assign Hot Keys to switch between layouts. If you highlight the “Between input languages” and click the Change Key Sequence, you alter what key combinations cycle between languages and keyboard layouts. I removed the cycle between languages because I only use US-English, and I assigned the Left Alt-Shift to cycle between keyboard layouts.

The last thing I did is back on the General tab, I went to the properties of the Dvorak keyboard and I changed the icon to a keyboard with a red border so that when my keyboard is in Dvorak mode the little Language Bar icon on the right side of the task bar is a read keyboard instead of the standard one.

QWERTY

Dvorak

No for the best part, or worst part, I’m not entirely sure yet. When you switch layouts, the switch only affects the app you were in when you switched layouts. So, I can keep my browser in Dvorak for typing practice, but Outlook and Visual Studio stay in QWERTY. I think this will come in handy in the long run as I can keep a say Outlook in Dvorak, and Visual Studio in QWERTY or vice versa depending on productivity. Eventually I’ll switch the default…

Typing Speed

Jeremy Hutchinson — Thu, 07 Jun 2012 00:00:00 UTC

So, I read one blog by Steve Yegge linked from CodePoject about typing speed (which is a great read if you have the time). Then Steve Smith tweeted his blog post on the same subject, which was in response to Jeff Atwood’s post. Apparently all 3 articles are from 2008, but I read them like they were news today.

Was that enough name dropping?

I read those 3 articles, and all 3 have the same premise. You should be a fast efficient typist if you write code for a living. They go almost as far as saying it’s the most important skill. I don’t think that’s true, but being a better typist will most likely make you a better programmer. If I code type as fast as I thought, I could either put out a bunch more code per day, or I could put out the same amount of code, just better thought out. Or some combination in the middle – a little more slightly better thought out code.

They also linked to this typing speed test. Steve Smith and Jeff Atwood were both in the mid 80′s and Steve Yegge claims 120 WPM. I have no reason to doubt Mr. Yegge, but his measurement may be from typing his own thoughts whereas the rest of us used the typing speed test where you are copying text and I think there’s quite a difference. I suspect Steve Smith and Jeff Atwood would easily put out 100+ WPM of their own thoughts.

Of course I tested myself and came up ~55 WPM. I did the test 3 times at 54, 56 and 54 WPM. Each test had between 1 and 3 errors. I was not impressed with my performance (partly why I took the test 3 times), so I’ve set a goal to double my speed on that test.

My plan is this: I’m going to switch to Dvorak layout for ~10-15 minutes a day and practice with some sort of online typing tutor. Once I have the keyboard memorized and I’m typing >30 WPM, I’m going to add a few hours a day in Dvorak, the rest in Qwerty. Once I hit >50 WPM, I’ll switch to full-time Dvorak, and continue with the typing tutors for the 10-15 minutes per day until I reach 110 WPM.

Through this I’m going to try to update here every week or two to report progress.

—excerpt—

Using a different DataTemplate when a WPF ComboBox is expanded

Jeremy Hutchinson — Tue, 05 Jun 2012 00:00:00 UTC

A quick post showing how to create a combo box that shows a single line, shows multiple lines when expanded. Obviously you can extend this to show any two datatemplates for collapsed and expanded.

The first thing I did was create the data templates that control how the address is going be displayed. When it’s collapsed, I just wanted to show the AddressName and AddressType on one line:

<DataTemplate x:Key="AddressComboCollapsed" >
    <StackPanel Width="150" HorizontalAlignment="Stretch" >
        <DockPanel HorizontalAlignment="Stretch">
            <TextBlock Text="{Binding Path=AddressName}" 
                       DockPanel.Dock="Left" />
            <TextBlock Text="{Binding Path=AddressType}" 
                       DockPanel.Dock="Right"
                       HorizontalAlignment="Right" />
        </DockPanel>
    </StackPanel>
</DataTemplate>

When it’s expanded, I want to show the whole address and suppress AddressLine2 if it’s blank:

<DataTemplatea x:Key="AddressComboExpanded" >
    <GroupBox BorderThickness = "1"
              Margin = "0,0,0,3"
              Width = "Auto "
              HorizontalAlignment = "Stretch"
              Header = "{Binding Path=AddressType}">
        <StackPanel Margin="3" 
                    HorizontalAlignment="Stretch"
                    MinWidth="250">
                <TextBlock Text = "{Binding Path=AddressName}"/>

            <TextBlock Text = "{Binding Path=AddressLine1}"
                       Name = "tbAddr1" />
            <TextBlock Text = "{Binding Path=AddressLine2}"
                       Name = "tbAddr2" />

            <!-- City, State, and ZIP display -->
            <StackPanel Orientation = "Horizontal">
                <TextBlock Text = "{Binding Path=City}" />
                <TextBlock Text="," Padding="0,0,5,0"/>
                <!-- Put a comma between city and state -->

                <TextBlock Text = "{Binding Path=State}" Padding="0,0,5,0" />
                <TextBlock Text = "{Binding Path=PostalCode}" />
            </StackPanel>
        </StackPanel>
    </GroupBox>

    <DataTemplate.Triggers>
        <!--If the "AddressLine2" portion of the address is blank, then
            HIDE it (no need to display an extra blank line)
            
            This only works is AddressLine2 = "", not if it's null
        -->
        <DataTrigger Binding = "{Binding Path=AddressLine2}" Value = "">
            <Setter TargetName = "tbAddr2" 
                    Property = "Visibility" 
                    Value = "Collapsed" />
        </DataTrigger>
    </DataTemplate.Triggers>
</DataTemplate>

The next step was to create a AddressTemplateSelector class that inherits from System.Windows.Controls.DataTemplateSelector.DataTemplateSelector, and override the SelectTemplate method.

public class AddressTemplateSelector : System.Windows.Controls.DataTemplateSelector
{
    public override DataTemplate SelectTemplate(object item, DependencyObject container)
    {
        ContentPresenter presenter = (ContentPresenter)container;

        if (presenter.TemplatedParent is ComboBox)
        {
            return (DataTemplate)presenter.FindResource("AddressComboCollapsed");
        }
        else // Templated parent is ComboBoxItem
        {
            return (DataTemplate)presenter.FindResource("AddressComboExpanded");
        }
    }
}

After that, it’s just a matter of importing the namespace of the DataTemplateSelector into the Window, merging the Resource Dictionary that contains the DataTemplates, and setting the ItemTemplateSelector of the ComboBox.

<ComboBox Height="30" Width="200"
            ItemsSource="{Binding Path=Addresses}">
    <ComboBox.ItemTemplateSelector>
        <dt:AddressTemplateSelector/>
    </ComboBox.ItemTemplateSelector>
</ComboBox>

Point of Interest

If you look closely at the templates, you’ll notice that the expanded template is wider than both the combobox and the collapsed template. This allows you to have the list be wider than the original combobox. That’ll be a nice feature when I move on to the state selection combo (display only StateCode, but show StateCode + StateName when expanded).

WP7 Application Capabilities

Jeremy Hutchinson — Mon, 04 Jun 2012 00:00:00 UTC

WMPoserUser posted some interesting stats on what capabilities applications are requesting. Interesting stuff, but they clearly haven’t published an app, or at least not an ad supported app.

First let me say that I have only published a single app so far, so I’m not some amazing expert. My app, Chess Tactics, doesn’t actually need any capabilities by itself. That being said I have quite a few capabilities listed. Most of these capabilities are required by Microsoft’s ad control, with one additional capability required by MTIKS (a utility I’m using usage and error detail).

Here’s my capabilities list and why I include it and why I think it’s required:

Phone Dialer
- MS Ad Control – so you can dial a phone number direct from an advertisement
Networking
- MS Ad Control – to download ads for display and report any clicks
- MTIKS – Send data back for reporting
Web Browser
- MS Ad Control – to display the ads
User Identity
- MS Ad Control – to track what the users interests are across apps
- MTIKS – Track user loyalty across app versions and user device upgrades
Media Library
- MS Ad Control – No idea at all
Device Identity
- MTIKS – To track what devices are using my app in case a particular one become problematic

None of these capabilities indicate an app is trying to do anything nefarious. I would expect pretty much every app to need these capabilities. Now if an app wants access to my microphone, it better have a damned good reason.

Between collecting stats, serving ads, and apps that use network service to provide value, I think it’s out of line to say that 95% requesting network services is “larger than necessary”. In fact, it makes me wonder what the 5% of apps that don’t require network access are.

If you know why the MS ad control needs access to the Media Library please let me know in the comments.

How I got started as a developer

Jeremy Hutchinson — Wed, 30 May 2012 00:00:00 UTC

A response to a request for everyone to share how they got started down the road to become software developer.

I wrote my first code on a Kaypro II. My mother bought it around 1987, and there were 2 things you could do on it. You could use the word processor (I think it was WordStar) or you could program in some variant of BASIC. I did a little of both.

My mother had a handful of programming books left over from getting her Associates degree a few years earlier, and I would copy some of the sample applications, or try to do some of the problems in some of the chapters. Between the things the books left out and the bugs I added while hunting and pecking the code into the computer I had plenty of debugging to do. In some ways I wish I had some of that code, but mostly I’m glad the evidence has been destroyed.

Next my mother bought an IBM pc running Windows. My recollection was 3.1, but I’m almost certain I got it before 1992 so who knows? I don’t remember how much ram it had, maybe a couple of MB? I do remember the disk was 25mb.

The first challenge with that was to try to get this one flight simulator running on it. I spent weeks modifying the autoexec.bat and config.sys on a boot disk to loaded the absolute bare minimum into memory and get every configured just right to be able that flight sim. Then I spent countless hours playing purchased and/or pirated games and playing in Q-Basic.

Around that same time I got a programmable calculator for my high school math class. I started writing programs to do the math problems for me. I still had to show the work, but I could be certain the answer was correct. I also created a simple black jack game and a two player howitzer game with random landscape and wind.

All that and I chose sports medicine as my major in college? Yup. How I got from sport medicine back to software development would be a whole post in itself.

So really, it was my Mom who got me started down this path. She not only bought the computers, but she taught me how to debug. How to work through the problems. How to go step by step until you see where things where things go wrong. Skills I still use every day.

Thanks Mom.

What’s your story?

T4 Generated Wrapper for a WCF Client

Jeremy Hutchinson — Thu, 24 May 2012 00:00:00 UTC

Background

The idea for this article came from two places:

I’m writing an application that gets all of its data from a WCF service. Each time I call the WCF service, I end up having to write a bunch of duplicate code and of course I don’t like to type, so I was trying to find a way to not have to write that code.

The app I’m developing is an internal business application, and we release weekly. Each release to the WCF services could be incompatible with the previous client. That means that I need to do the release during off hours. I don’t like working nights, so I wanted to find a way to have multiple copies of the service running and have the client choose which service to access based on its version, but I didn’t want to have to keep changing the config file for the client with each release. First I’ll solve those two problems, and then I’ll demonstrate how to use T4 to generate this wrapper from the WCF service reference.

Prerequisites

To run the code, you’ll need to download and install the T4Toolbox.

Problem #1

A typical WCF call looks like this:

var proxy = new WCFServiceWrapper.WcfSvc.Service1Client()
try
{
    returnValue = proxy.GetData(value);
    proxy.Close();
}
catch
{
    proxy.Abort();
    throw;
}
Proxy = null;

To keep from having to write all that code every time I make a call to the WCF service, I created a static class that has a static method with the same signature as the WCF method I’m calling.

public static partial class SvcWrapper
{   
    public static string GetData(int value)
    {
        var proxy = GetServiceClient()
        try
        {
            var returnValue = proxy.GetData(value);
            proxy.Close();
            return returnValue;
        }
        catch
        {
            proxy.Abort();
            throw;
        }
    }
}

Now that same call that took 12 lines of code is now just this one line:

returnValue = SvcWrapper.GetData(value);

Problem #2

To solve the second problem, I just added another method that creates an instance of the service client for me.

public partial class SvcWrapper
{
    private static string _serviceAddress;
    private static string _configName;
    private static bool _needsConfig = true;
    internal static WcfSvc.Service1Client GetServiceClient()
    {
        if (_needsConfig)
        {
            //At this point I'd do some hoopajoop to determine what the
            //current service address is for this version
            //something like:
  
            //ServiceConfig config = SomeWCFService.GetServiceConfig(versionNo);
            //_serviceAddress = config.Address;
            //_configName = config.ClientEndPointName;
            //The address of the service endpoint
            _serviceAddress = "http://localhost:50324/Service1.svc"

            //This string is the Name of the Client Endpoint
            //as defined in the running EXE's app.config
            _configName = "WSHttpBinding_IService1";
        }
        return new WCFServiceWrapper.WcfSvc.Service1Client(_configName, _serviceAddress);
    }
}

There’s nothing earth shattering about that code, and I haven’t even implemented the look of the address and config yet, but the shell is there for me to finish at a later date. But now if I want to add another endpoint configuration to the app.config file for this service, I can do that and have only one place to change which endpoint the app uses.

Using T4 to Generate Wrapper Methods

Now, I’ve solved my original 2 problems, but I’ve created another one. I’m going to have to create and maintain a wrapper method for every method exposed by the WCF Service. This is the perfect opportunity to do a little code generation with T4.

First thing you need to do is add references to the EnvDTE and T4ToolBox. Then add a new text file called GenerateServiceWrapper.t4. This file holds the code that is not specific to the service we’re wrapping, and the t4 extension doesn’t create the child .cs file that the .tt extension creates.

This file has 5 methods:

GetServiceInterface – takes the name of the service and searches the project for a file that matches. Then it calls FindInterface. FindInterface – takes a project item and searches it for an interface. It returns the first one it finds, and nullif it doesn’t find one. It could maybe use some error handling but… GetMethodSignature – this takes one of the public methods found on the interface and returns a string that will be the method signature of the wrapper method. GetMethodCall – this takes one of the public methods found on the interface and returns a string that will be the call to that method on the WCF Service. GetServiceWrapper – is where the rubber meets the road. This calls GetServiceInterface to get the interface, loops through the public methods and generates the wrapper methods. Here’s the contents of that file, you’ll need to get a third-party plugin to get syntax highlighting in Visual Studio.

<#@ Template Language="C#" #>
<#@ import namespace="EnvDTE" #>
<#@ include File="T4Toolbox.tt" #>
<#+
public void GetServiceWrapper(string LocalServiceName)
{
    EnvDTE.CodeInterface svcInterface =
    GetServiceInterface(LocalServiceName + @"reference.cs");
    foreach (var ce in svcInterface.Members)
    {
        var meth = ce as CodeFunction;
        if (meth != null)
        {
            if (meth.Access == vsCMAccess.vsCMAccessPublic)
            {
                string methodSignature = GetMethodSignature(meth);
                string methodCall = GetMethodCall(meth);
                bool returnsVoid = false;
                if (meth.Type.AsString.Equals("void"))
                {
                    returnsVoid = true;
                }
                #>
        <#=methodSignature #>
        {
            var proxy = GetServiceClient();
            try
            {
            <#+
                if (returnsVoid)
                {
                       #>    proxy.<#=methodCall #>;
                            proxy.Close();
            <#+
                }
                else
                {
            #>    var returnValue = proxy.<#=methodCall #>;
                proxy.Close();
                return returnValue;
<#+
                }
#>
            }
            catch
            {
                proxy.Abort();
                throw;
            }
        }
         
<#+
            }
        }
    }
}

public EnvDTE.CodeInterface GetServiceInterface(string interfaceFile)
{
    ProjectItem projectItem = TransformationContext.FindProjectItem(interfaceFile);
    FileCodeModel codeModel = projectItem.FileCodeModel;
    return FindInterface(codeModel.CodeElements);
}
 
public CodeInterface FindInterface(CodeElements elements)
{
    foreach (CodeElement element in elements)
    {
        CodeInterface myInterface = element as CodeInterface;
        if (myInterface != null)
            return myInterface;
        myInterface = FindInterface(element.Children);
        if (myInterface != null)
            return myInterface;
    }
    return null;
}
 
public string GetMethodSignature(CodeFunction method)
{
    var methodSignature = new System.Text.StringBuilder();
    methodSignature.Append("public static ");
    methodSignature.Append(method.Type.AsString);
    methodSignature.Append(" ");
    methodSignature.Append(method.Name);
    methodSignature.Append("(");

    bool isFirstParameter = true;

    foreach (var prm in method.Parameters)
    {
        CodeParameter p = prm as CodeParameter;
        if (!isFirstParameter)
        {
            methodSignature.Append(", ");
        }
        else
        {
            isFirstParameter = false;
        }

        methodSignature.Append(p.Type.AsString);
        methodSignature.Append(" ");
        methodSignature.Append(p.Name);
    }

    methodSignature.Append(")");

    return methodSignature.ToString();
}
 
public string GetMethodCall(CodeFunction method)
{
    var methodCall = new System.Text.StringBuilder();
    methodCall.Append(method.Name);
    methodCall.Append("(");

    bool isFirstParameter = true;

    foreach (var prm in method.Parameters)
    {
        CodeParameter p = prm as CodeParameter;

        if (!isFirstParameter)
        {
            methodCall.Append(", ");
        }
        else
        {
            isFirstParameter = false;
        }
        methodCall.Append(p.Name);
    }
    methodCall.Append(")");
    return methodCall.ToString();
}      
#>

Lastly create a text file named ServiceWrapper.tt, or something less generic as this will define the actual wrapper for the WCF Service.

It contains a link to our GenerateServiceWrapper.t4 file, the definition of our class, and a call to GetServiceWrapper to which we pass the name of the WCF Service Reference.

<#@ template language="C#v3.5" hostspecific="True" #>
<#@ include File="T4TemplatesGenerateServiceWrapper.t4" #>
using System;
 
namespace WCFServiceWrapper
{
    public static partial class SvcWrapper
    {   
<#      GetServiceWrapper("WcfSvc");#>
    }
}

Once you save, it should generate a SvcWrapper.cs file with static methods to wrap all of your calls. Now if I want to do something like add logging to each WCF call, all I have to do is add that code to the GetServiceWrapper method in the GenerateService.t4 file, poof all my methods WCF calls are logged.

Notice that I created this class as a partial class, this allows us to put the GetServiceClient method in the same class, but in a separate file. We could have either created that method in a completely separate class, or within the ServiceWrapper.tt file. You never want to edit the generated file, as those edits will be overwritten.

Points of Interest

Syntax highlight for T4 requires a 3rd party plugin. I’ve tried a few, and they are all pretty weak.

You can’t step through T4 code (or I haven’t figured out how), so it can take some serious guess and check to figure out what’s going wrong when something goes wrong. The output window is your friend.

App Reviews

Jeremy Hutchinson — Tue, 22 May 2012 00:00:00 UTC

A quick word about app reviews:

Most people don’t review. I average about 1000 ad impressions a day. In other words users are playing 1000 minutes a day. So there are people who are using Chess Tactics but are not reviewing it. There have been about 1500 downloads, and only 8 reviews in the US.
Most reviews are not that helpful. I have a handful of reviews that are on the low-end with no indication about what they don’t like. Either they left it blank or just state they didn’t like it. One Australian rated it a 1 star and commented that he wished he could give it zero stars.
Fixing complaints doesn’t necessarily raise your rating. There were a couple of reviews that complained about having time factored into the scoring. I put out an update that allowed them the option to remove the time factor from the scoring. One reviewer did re-rate the app, but they left the negative part of the review, and just added that it was fixed at the end. The other reviewer hasn’t changed his rating yet.
It’s hard not to take it personally. I worked hard on the app in my and the negative feedback is frustrating. I just have to keep in mind that even wildly successful products have a handful of people who think it’s crap. Just take a look at the review for any product on Amazon.

What I really wish was available through the review system was a way to reach out to those who did review the app, or respond to reviews. How nice would it be to attach a comment to a low review that disliked the time factor is scoring to let them and the world know that I took their feedback and fixed their issue. Or maybe it would be nice to email the user, but I understand that could open up an opportunity for abusing negative voters.

I did include a feedback email address in my app, and I have received responses from 2 users. One had a question about a particular problem, and the other suggested an option to keep the phone from sleeping (coming next release). I really enjoyed those interactions, and I hope there are more.

Finally, I hope this experience changes the way I review apps and give feedback. If it’s at all possible I will give specific feedback in the review. I’ll also try to follow-up with an email so they can let me know if they change what I didn’t like about an app, so that I can adjust my review.

Minimum Requirements

Jeremy Hutchinson — Sun, 20 May 2012 00:00:00 UTC

The Visual Studio team just announced that the Visual Studio 11 will have the same hardware requirements as Visual Studio 2010. So, we’re getting more features, they’ve improved the performance throughout (yes, I am using it and the differences are obvious in places), and we could run it on yesterdays hardware, but we’re likely to have upgraded since then so faster still.

This seems to be a trend at Microsoft, or at least I hope it is. Earlier this year (or was it at Build last September) they announced that they had improved the performance and memory usage in Window 8 to the point where it was faster than Windows 7, used less memory and that the minimum requirements wouldn’t change from the Windows 7 minimums.

For so many years improvements in hardware were negated by bloat in software. If this trend continues we should be computing noticeably faster in a few years. Combine that with Microsoft’s push around asynchronous programming and the user experience a few years from now could be vastly better than it is today.

Of course Microsoft can only do so much, it’s now up to the world 3rd party and in-house developers to take up the challenge and write software that uses less memory, performs better and runs all long running processes asynchronously. Microsoft targeted processes that take longer than 50 ms, I might raise my target a bit above that, but I am accepting the challenge.

Mobile Analytics

Jeremy Hutchinson — Sat, 12 May 2012 00:00:00 UTC

In my previous post I complained about the 6 day delay in getting download number from Microsoft. Since then I have done a little bit of research into other ways of getting that information in a more timely manner. I found two good options MTIKS and Flurry. They both provide much more information than I was looking for from Microsoft, and I will be using one or the other unless I find something better.

They are both very easy to use. All you need to do is add a reference to their dll, then add one line of code to Application_Launching and Application_Activated to tell them to start a session, and another line to Application_Deactivated and Application_Closing to tell them to end the session.

They both also allow you to report exceptions and events. This would allow me to see how many problems users are playing, or what percentage of users turn off time based scoring in Chess Tactics.

Of course each has their strength and weakness.

MTIKS

MTIKS biggest strength is that it can detect pirated apps so you can see how big of a problem pirated apps are for you. My apps are all free at this point, so I’m not worried about pirates, and this feature isn’t a great selling point for me.

The other thing I really like about MTIKS was that it was real time (or very close to it). I could start up a session in the emulator, click refresh on their site and see the session.

The one problem I did see with MTIKS is in their exception handling. The stack trace gets overwritten if you log the error for Application_UnhandledException. I contacted them about this and they responded quickly and are looking into the problem. I’ll update this when they fix it.

Flurry

Flurry looks like it does a great job on the reporting side. They allow you to compare your app to the aggregate data of other apps collecting the same info. It lets you segment your reporting based on your users age, gender, language, location and even custom events (user who clicked the review this app button for example). If you’re not collecting this information, Flurry will make some estimates for you.

The downside here is that Flurry runs on a about a 1 hour delay. I of course would prefer instant gratification, but 1 hour isn’t too long to wait. Right now I’m facing a 6 day delay in download numbers and a 3 day delay in exception reporting, so one hour seems totally resonable.

Microsoft’s App Reporting

Jeremy Hutchinson — Thu, 10 May 2012 00:00:00 UTC

Warning, this is going to be a bit of a rant, but it’s been driving me crazy for a little while.

If you’re following along (and chances are no one is) you know that I recently released my first app for Windows Phone. Since then, I have been following the apps progress in downloads and ad revenue through Microsoft’s provided reporting tools on both PubCenter and AppHub. The reports are pretty decent for the most part, and give me the data I’m looking for except for 1 things. The lag in data.

The data for ad revenue is delayed by 3-6 hours (I’ve seen as much as 12 hours). It drove me crazy when I first released the app because it was the only data I could get. I’ve made my peace with this and I now only check the previous day’s total, and I don’t do that every day.

The delay that really grinds my gears is the downloads number in the AppHub. That number is delayed 6 days. There reasoning? That’s how long it takes to process credit card transactions.

Wait, I wasn’t reporting on number of sales, I was reporting on number of downloads. People can download my app for free, other apps have a trial period. Why are the download numbers for those being delayed? If your app is trial/buy, the report doesn’t give you an accurate reflection of sales, nor does it give you an up to date number of downloads.

I suggest this: Allow us to view reports of downloads and trials in a much more up to date fashion. A 1 day delay at most. And have another option to view the number of sales which would be delayed by the 6 days it takes to process a credit card.

401 Unauthorized error on MERGE operations IIS 7 with WCF Data Service

Jeremy Hutchinson — Mon, 30 Apr 2012 00:00:00 UTC

I was getting this error when using WCF Data Services and trying to save an update to an object. After quite a bit of googling, I found a work around that I didn’t like. Allow the users write access to the .svc file.

I have a hard time believing that anyone would accept “allow the user write access to the file” as an answer in web situation. In my case I was able to use that as a temporary fix because the website in question was internal and behind a firewall, but I knew there had to be a better answer.

UsePostTunneling

Post tunneling allows you to use your REST service with just the Post and Get verbs, and puts a little something extra in the header so that the service knows to treat the Post as a Merge, Put or Delete verb. For WCF Data Services, all you need to do is set the UsePostTunneling property on the Context to true.

Here’s sample code from anonymized from my dataservice factory:

public static MyDataSvc.MyDataEntities GetDataSvc()
{
    Uri SvcUri = new Uri(string.Format("http://myserver.com/", "dataservice.svc"));
    var context = new MyDataSvc.MyDataEntities (SvcUri);
    context.UsePostTunneling = true;
    return context;
}

Why am I blogging? Because Scott asked me to

Jeremy Hutchinson — Mon, 23 Apr 2012 00:00:00 UTC

Seriously, Scott Hanselman, one of the premier software development bloggers and all around dev guru, asked me to blog. He wrote a whole blog post about how important he thought it was that I start blogging. It seems he really thinks I have something to add to the conversation, and that someday he will find answers to some of his questions when a Google search turns up my blog.

OK, so he wasn’t speaking specifically to me, but I had been thinking about starting to blog because I’m at a point where I do think I have something to add to the conversation, and I may actually be able to post about a coherent article on some problem I’ve overcome that took researching 3+ pages deep in Google results for a hint that pointed me in the right direction.

Basically I was ready to start blogging, and Scott just pushed me over the edge. And for that I say thanks.

**I was watching a video of one of Scott’s presentations where he said that he wants to beat out Scotts toilet paper as the top result when searching for Scott. To do that, he proposed that when linking to his site everyone link on the word Scott. I’m not sure if he was joking, but I went with it anyway.

The greatest feature of all

Jeremy Hutchinson — Sun, 22 Apr 2012 00:00:00 UTC

Today was a big day in my life as a developer. I added the most important feature to my application. This is the first time I have ever added a feature of such magnitude to an application I wrote as a side project. You might be wondering what this wonderful feature of which I speak?

SHIPPING!!!

Did it really need to be in bold, with 3 exclamation points? Yes, I think it did. This is a huge accomplishment on a personal level. I have started and not finished at least a dozen other projects in my life. The all start out the same way. I think “Hey, this technology is really cool, I should build something.” I find an idea and after I’ve fully explored the technology, I never finish the last 20% of the project. You know the 20% that takes 80% of the effort.

I always learn a lot from these side projects, but this is the first time I’ll really have something to show for it. Am I proud of the code? Absolutely not. I was working with an open source chess engine (from ChessBin.com) to setup the board and validate moves. I had to do some things that made me cringe at times to get things working. The alternative was to spend weeks refactoring the chess engine with the hope of not breaking it while converting it from something designed for WinForms to something designed for MVVM. I chose the shortcut so that I could add other features, like shipping.

Is my app going to change the world? Is it going to make me rich? Absolutely not. I expect to get dozens of downloads per year, and hope to make back the $99 I paid to publish it over my lifetime.

Will I try to publish another loss producing app in the future? Yes. This whole thing has been a great learning experience, both development and product management wise. I’m sure I’ll learn a lot about marketing in the coming months as well.

If you have a Windows Phone please check it out. If like it give me a nice 5 star rating. If you don’t like it send me an email and tell me what you’d do differently.