Goatly.net

Obfuscated assemblies and MSIX packaging: the mixed-build trap

Thu, 26 Mar 2026 00:00:00 +0000

If you’re packaging a .NET desktop app for the Windows Store using a WAP (Windows Application Packaging) project, and you’re also running an obfuscator as a post-build step, there’s a subtle trap waiting for you. The app works perfectly when you run the desktop .exe directly — but the packaged version crashes immediately on startup with a cryptic native exception.

This post walks through what’s going wrong, how to confirm it with ILSpy, and how to fix it with a small addition to your .wapproj.

LIFTI v7: Eliminating Allocations with CharacterBuffer

Thu, 27 Nov 2025 00:00:00 +0000

LIFTI is an open source full text index library for .NET - you can check it out on GitHub

Performance has always been a core focus for LIFTI. For v7, I looked at the tokenization pipeline and found an opportunity to significantly reduce memory allocations. The solution? Replacing StringBuilder with a custom CharacterBuffer backed by ArrayPool<char>.

The problem

During tokenization, LIFTI builds up character sequences from the input text. Previously, this used StringBuilder - a perfectly reasonable choice, but one that allocates a new string every time you call ToString(). When indexing 100,000 tokens with 50% duplicates, that’s roughly 50,000 unnecessary string allocations for tokens we’ve already seen.

LIFTI v7: Anchoring Queries to Field Boundaries

Tue, 25 Nov 2025 00:00:00 +0000

LIFTI is an open source full text index library for .NET - you can check it out on GitHub

LIFTI v7 introduces anchor operators that let you constrain matches to the start or end of fields. This feature was requested for exact match scenarios - like finding records where a field contains exactly one specific value, or where text starts or ends with particular words.

The syntax

The anchor operators are simple:

LIFTI v7: The And-Not Operator

Sun, 23 Nov 2025 00:00:00 +0000

LIFTI is an open source full text index library for .NET - you can check it out on GitHub

LIFTI v7 introduces a new query operator that’s been on my wishlist for a while: the And-Not operator (&!). This operator allows you to efficiently subtract one set of search results from another - perfect for those “find this but not that” scenarios.

The use case

Imagine you’re searching a collection of documents about Paris. You want documents mentioning “eiffel” but you’re specifically not interested in the tower - maybe you’re researching the engineer Gustave Eiffel himself. With the new operator, you can write:

Azure DevOps AzureStaticWebApp: specifying Hugo version

Thu, 12 Jun 2025 00:00:00 +0000

I use Azure Static Web Apps in a couple of places, this blog and the Chordle site. While updating the templates they use, I found that the deployment builds started to break because the included Hugo version was out of date.

The first I fixed up was this blog. I was getting this error:

template: partials/func/getStylesBundle.html:4:90: executing “partials/func/getStylesBundle.html” at : can’t evaluate field Sass in type interface {}

This is deployed using GitHub actions, and I found this documentation helped me resolve it there - I simply had to add the Hugo version as an environment variable to the build task.

Coding With ChatGPT

Tue, 06 Dec 2022 00:00:00 +0000

This post is me having a conversation with an AI called ChatGPT, using it as a time saving tool for writing code. I’d been thinking about some code I needed to write in LIFTI. I knew what I wanted it to do and how I was going to implement it, but as an old friend once told me “Just because you know how to do something, doesn’t mean it takes zero time”. So I figured I’d have a bit of fun with ChatGPT.

Creating temporary Azure CLI login sessions

Tue, 01 Nov 2022 12:26:21 +0000

The Azure CLI is my preferred way of working with Azure from the command line - I love the discoverability of the commands. az --help is always a great reminder of the root commands and I can keep applying --help as I work my down the various levels - it’s much easier to remember than all the various Az PowerShell commands.

You always start with an az login to sign into Azure, but there may be times you need to temporarily connect as another account to the same subscription. If you use az login again, you’re effectively signing out the previous account and there’s no way to switch back to the original account without going through another az login.

Custom query parsers in LIFTI

Fri, 11 Feb 2022 00:00:00 +0000

LIFTI is an open source full text index library for .NET - you can check it out on GitHub

The Visual Studio Go To Symbol feature is smart enough that if you miss out letters it can still match with pretty good accuracy:

Now that LIFTI support wildcard matching (and fuzzy matching too!) I thought this would be a good little demonstration of how you could customize LIFTI to behave in a similar way.

Test Your Azure Function Http Trigger Authorization Levels

Thu, 17 Dec 2020 09:24:03 +0000

If you are using HTTP trigger bindings and are relying on keys to secure them using AuthorizationLevel.Function, you might want a way verify that you haven’t accidentally left one of them exposed as AuthorizationLevel.Anonymous.

With a bit of reflection you can accomplish this in a unit test (I’m using the excellent xUnit and FluentAssertions here):

 1[Fact]
 2public void AllHttpTriggerFunctions_MustHaveFunctionSecurity()
 3{
 4    // Get the assembly containing the Azure Functions
 5    var types = typeof(Startup).Assembly.GetTypes();
 6
 7    // Find all the HttpTriggerAttributes associated to any method in any of the types
 8    // in the assembly
 9    var httpTriggerAttributes = types
10      .SelectMany(t => t
11        .GetMethods()
12          .Select(m => m.GetParameters()
13            .Select(p => p.GetCustomAttribute<HttpTriggerAttribute>()).FirstOrDefault()))
14      .Where(p => p != null)
15      .ToList();
16
17    httpTriggerAttributes.Should().NotBeEmpty();
18
19    foreach (var httpTrigger in httpTriggerAttributes)
20    {
21        httpTrigger.AuthLevel.Should().Be(AuthorizationLevel.Function);
22    }
23}

That’s it. Now it’s even harder to make a mistake, which is a good thing.

File Globbing in .NET

Mon, 07 Dec 2020 17:16:21 +0000

If you’ve ever written entries in a .gitignore file, you’ve written a glob. They can be simple, e.g. *.so matching all files with the so file extension, or a more complex, e.g. **/bar/*.cs matching files with the cs extension in folders called bar anywhere in the search path.

This is very different to the simple wildcard patterns that you can apply to the usual .NET IO functions, which only allow for matching wildcards against filenames, e.g. Directory.GetFiles(folder, "*.cs").

Blog Rebuild

Tue, 25 Aug 2020 17:27:46 +0100

Like a phoenix from the ashes this blog has been reborn! I thought it might be interesting to talk about the new architecture, as well as the process I went through to migrate it.

TL;DR I used:

Hugo to build the site

Azure Static Web App for hosting

CloudFlare to deal with the top level domain redirection

A custom tool called html2md to convert my old HTML content to markdown.

Objectives

Use a static site generator. As much as I like CMS’, for the frequency at which I post they are overkill. Not having to maintain server side logic and a database is also a win.
Keep all the old content, including dealing with redirects.
If possible, use this as an opportunity to try new technologies.

Static Site Generation

I decided to use Hugo, having had some success with it recently while building the new LIFTI v2 documentation. I used the Clarity theme with some minor customizations, such as swapping out Google Tag Manager for Application Insights to track page views. You can have a look around the site’s code in the GitHub repo.

Adding Application Insights to an existing Windows Store project using Visual Studio 2013 Update 3

Thu, 07 Aug 2014 11:55:08 +0000

As of Update 3, Visual Studio 2013 now has support for Application Insights built in, so I thought I’d have a play with it again.

Right now, my primary focus is adding instrumentation to a Windows 8 Store app I’m working on. I’d tried to do it with the previous Application Insights release (which was in preview), but found the need to explicitly build the app for all the various CPU targets a burden I could do without. The release that comes with Update 3 would seem to have fixed this, by allowing you to target Any CPU.

Fixing NuGet errors after removing Microsoft.Bcl.Build

Tue, 05 Aug 2014 20:20:36 +0000

I found that a solution of mine was still referencing the Microsoft.Bcl.Build nuget project, and as I was using Visual Studio 2013, I figured it was no longer needed, so I removed it. After doing this, some of the projects refused to compile, reporting the error:

This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=317567.

After I remembered that this package modifies the project files a little, I fixed the broken projects by:

Using DynaCache with SimpleInjector

Fri, 20 Jun 2014 11:39:50 +0000

@Colly_Mc_K asked me on twitter (and in my poorly moderated comments feed – sorry, Colly!) if it was possible to use DynaCache with SimpleInjector.

Although I’ve used SimpleInjector a bit before, I hadn’t actually tried it with DynaCache. It turns out that the sample code for Ninject translates fairly well - here’s a sample bit of code that should do the trick with SimpleInjector:

Customizing table names for IdentityDbContextWithCustomUser data contexts

Mon, 23 Sep 2013 18:53:11 +0000

I was playing around with Visual Studio 2013 and Entity Framework 6 in an MVC 5 application recently, and was impressed with the level of support that is provided out of the box for oAuth. If you create a new ASP.NET MVC 5 site with the Individual User Accounts authentication option and follow all the instructions on MSDN, it’s trivial getting at least Google authentication working against a new site.

If you follow the instructions through to the end, you’ll end up having a data context that derives from IdentityDbContextWithCustomUser, where TUser is your custom user entity that derives from [NAMESPACE]User.

PersistedFullTextIndexes with non-primitive types

Mon, 27 May 2013 09:03:00 +0000

When you construct a PersistedFullTextIndex with a primitive type, such as int, you just need to define it like this:

1var index = new PersistedFullTextIndex<int>(filePath);

However if you try to do this with something more complicated, such as a class or even just a Guid, you’ll get an exception like this:

1Unable to automatically serialize type Guid

This because the framework doesn’t know how to (de)serialize these types when reading and writing to the backing file. In order to get this working, you have to provide the index with an implementation of ITypePersistence for the type of object that you’ll be serializing.

Using DynaCache with Unity

Sat, 18 May 2013 11:35:38 +0000

I’ve had a couple of people ask for concrete examples of using DynaCache with frameworks other than Ninject. The first one that I’ve put together is for Unity.

You’ll find the Unity example in the DynaCache documentation here.

StoryboardCompletedTrigger and SetPropertyAction

Thu, 21 Mar 2013 20:31:59 +0000

I’ve spent a couple of hours on WinRTTriggers tonight and added a couple of features that have been requested recently, StoryboardCompletedTrigger and SetPropertyAction.

StoryboardCompletedTrigger

This trigger allows to to fire an action when a storyboard completes – you can use it like this:

1<Triggers:StoryboardCompletedTrigger Storyboard="{StaticResource FlashNameChanged}">
2    <!-- insert your action(s) here -->
3</Triggers:StoryboardCompletedTrigger>

SetPropertyAction

This allows you to react to a trigger by setting a property on an object – most likely your view model:

Aliens vs Finger

Mon, 25 Feb 2013 19:09:00 +0000

I’ve been working on another game for Windows Phone (7.5+) and the result is Aliens vs Finger!

Aliens vs Finger is a (hopefully!) fun tap-’em-up game where you have to squish the aliens and stop the meteors crossing the screen, all the while being careful to not hit the friendly spacemen. Although it’s in the market place as a paid app (the lowest price possible!) - the entire game is available as an ad-supported trial, so you’ve got nothing to lose by giving it a go - only purchase if you enjoy it!

Using Azure Mobile Services from Windows Phone 7 apps

Sat, 10 Nov 2012 16:04:00 +0000

Azure Mobile Services is an pretty cool platform that I’ve only just started trying out. Microsoft provide quick jumpstart projects for Windows Store, Windows Phone 8 and iOS apps – but that’s it. If you’re like me and are stuck working on a “legacy” app such as the Windows Phone 7 game that I’ve been working on for a couple of weeks now, then you’re largely on your own.

If you’re in the same situation, I would recommend that you check out the azure-mobile-csharp-sdk project by Ken Egozi. It seems to do everything I need – at the moment just querying and inserting - right off the bat, and it looks like the Mono guys have even taken to using this code in the Mono framework, so that’s a good sign as well!

Using WinRTTriggers within data templates

Sat, 03 Nov 2012 13:14:12 +0000

Kaki104 recently commented that they were having a problem using triggers in a certain situation. Helpfully a simple repro was provided – a simple grid view, with an attempt to start a storyboard when an item is clicked:

The trigger had been placed within the data template of the item:

 1<DataTemplate x:Key="DataTemplate1">
 2    <Grid HorizontalAlignment="Left" Width="250" Height="250">
 3        <Grid.Resources>
 4            <Storyboard x:Key="storyboard1">
 5                <ColorAnimationUsingKeyFrames Storyboard.TargetProperty="(Border.Background).(SolidColorBrush.Color)" Storyboard.TargetName="border">
 6                    <EasingColorKeyFrame KeyTime="0" Value="#FFB8B5B5"/>
 7                    <EasingColorKeyFrame KeyTime="0:0:1" Value="#FF3C3B3B"/>
 8                </ColorAnimationUsingKeyFrames>
 9                <ColorAnimationUsingKeyFrames Storyboard.TargetProperty="(Panel.Background).(SolidColorBrush.Color)" Storyboard.TargetName="stackPanel">
10                    <EasingColorKeyFrame KeyTime="0" Value="#A69C5151"/>
11                    <EasingColorKeyFrame KeyTime="0:0:1" Value="#A6F9F3F3"/>
12                </ColorAnimationUsingKeyFrames>
13            </Storyboard>
14        </Grid.Resources>
15
16        <t:Interactions.Triggers>
17            <t:PropertyChangedTrigger Binding="{Binding Title}">
18                <t:ControlStoryboardAction Action="Start" Storyboard="{StaticResource storyboard1}"/>
19            </t:PropertyChangedTrigger>
20        </t:Interactions.Triggers>
21
22        <Border x:Name="border" Background="#FF3D3D3D"/>
23        <StackPanel x:Name="stackPanel" VerticalAlignment="Bottom" Background="#A6000000">
24            <TextBlock Text="{Binding Title}" Foreground="{StaticResource ListViewItemOverlayForegroundThemeBrush}" Style="{StaticResource TitleTextStyle}" Height="60" Margin="15,0,15,0" LayoutUpdated="TextBlock_LayoutUpdated_1" SelectionChanged="TextBlock_SelectionChanged_1"/>
25            <TextBlock Text="{Binding Subtitle}" Foreground="{StaticResource ListViewItemOverlaySecondaryForegroundThemeBrush}" Style="{StaticResource CaptionTextStyle}" TextWrapping="NoWrap" Margin="15,0,15,10"/>
26        </StackPanel>
27    </Grid>
28</DataTemplate>

Interestingly the designer complains that there is an “illegal qualified name character” in the XAML, but when you run the code, everything works as expected.

Using LiveDataScript

Sat, 13 Oct 2012 12:50:47 +0000

LiveDataScript is a little utility to generate SQL insert scripts from SQL Server databases. I wrote it quite a few years ago, but since it’s still fairly useful and the last place it was hosted has now gone the way of the Dodo, I’ve re-hosted it here.

This post will cover the high-level basics of using the application.

Getting started

After starting LiveDataScript you’ll be prompted to select the server to connect to:

Conditional trigger actions with WinRTTriggers

Sun, 07 Oct 2012 20:23:43 +0000

WinRTTriggers is a available from the codeplex project site or from nuget.

Sample code for this post can be downloaded here.

The latest update to WinRTTriggers (v1.1.0) includes 2 big changes:

Multiple actions can be specified against a trigger
An action can have conditions associated to it

The first point is fairly self explanatory, but the second deserves a bit more elaboration.

Take the situation where on the first use of your application you want to introduce the user to certain features using a storyboard animation. In the view model you might have some flag to indicate “first use”:

Triggers in WinRT XAML

Fri, 28 Sep 2012 16:04:00 +0000

All the code for WinRTTriggers is available from the CodePlex project site, and is available in binary form in a nuget package.

A few months ago I attended one of Microsoft’s “Windows Phone to Windows 8 App” events. The intent was to take Equazorand migrate it to a Windows Store application as much as possible over the space of two days.

On the whole, the event was really useful to just hang out with a bunch of other developers (along with some Microsofties like Mike Taulty and Martin Beeby) and I managed to port all the “business logic” of the app pretty successfully - you would expect so given that I had used the MVVM pattern with MvvmLight, which is now available for WinRT XAML applications.

Equazor

Thu, 20 Sep 2012 21:08:00 +0000

A couple of months ago I released my first Windows Phone game into the wild. It’s a “maths-based puzzle game” that will challenge, infuriate (hopefully not too much!) and with a bit of practice, genuinely develop your mental arithmetic.

The premise is simple – you have to highlight a sequence of tiles forming an equation that results in a target number. It’s easy to start with, with just add and subtract and a limited number of tiles to play with, but it soon gets harder when the multiplication is introduced and the playing area and target numbers get larger. Oh, and you’re up against the clock, so there is some pressure!

New host, new look

Wed, 19 Sep 2012 19:09:00 +0000

There hasn’t been much activity here for a while for several reasons, including a new job and the small matter of a total server failure for a few months…

…but now I’m back. I’m on a new host, a new platform (Orchard) and have a new look that I threw together – ok, I’m no professional graphic designer, but hey, it adapts to small screens nicer than the last one did!

Export all tables in an Access database to CSV

Tue, 29 May 2012 00:00:00 +0000

I don’t usually mess around with Access much, but when I do it’s usually to have it act as an intermediary data source while I’m getting data from one format to another.

I had just such a problem to solve today, and the usually excellent out-of-the-box import/export processes let me down a little. Essentially I needed to get the data from each of the tables into separate CSV files - unfortunately I had quite a few tables to do and the UI only allows you to do one at a time.

Why have my visual state changes stopped working?

Tue, 22 May 2012 00:00:00 +0000

This took me a little while to work out, and searching for an answer didn’t help me out, so I thought it might be helpful to post this as a pointer to anyone else who encounters the same problem.

My scenario:

A Silverlight Windows Phone 7.1 App
a control with a number of visual states applied to it
Interaction triggers that switch between the various states

Everything was working fine until I wrapped the root element of my control in another container element - all of a sudden the visual states stopped working at runtime. As far as the designer was concerned, everything was fine though.

Hooking into session start events in an HTTP module

Wed, 25 Jan 2012 00:00:00 +0000

According to the MSDN documentation you can’t handle Session Start events in an HTTP module. The reason for this is because when you are initialising an HTTP module you hook into events associated to the HttpApplication class, and HttpApplication doesn’t expose any events relating to the starting of sessions.

As a refresher, the Init method will typically look like something like this:

1public void Init(HttpApplication context)
2{
3    // Hook into the HttpApplication events you want to respond to
4    context.BeginRequest += this.BeginRequest;
5}

So it’s not possible… right? Wrong, but only if you don’t mind a slightly dirty hack.

Article on using SqlBulkCopy with POCOs

Fri, 20 Jan 2012 00:00:00 +0000

I realised that I never pushed this on my blog at all, so belatedly I will.

Last year I wrote an article for Developer Fusion that discussed how you could make use of SqlBulkCopy to do high performance inserts when you were working with POCOs, rather than inserting them entity by entity using an ORM.

The bottom line was that inserting 10,000 records took only 57ms using the generic SqlBulkCopy approach I describe, rather than 2159ms to insert them on a record-by-record basis.

DynaCache- just like page output caching, but for classes

Sun, 15 Jan 2012 00:00:00 +0000

Anyone who has done any serious work with any ASP.NET based framework will know that page output caching is a great feature. For those not familiar with it, the basic premise is that it makes sure that the generation of content is done only once for a set of parameters, and that all subsequent requests with the same parameters are served up from the cache for a specified period of time.

Tutorial: Using LIFTI in an MVC 3 web application

Fri, 01 Jul 2011 00:00:00 +0000

Updated 25/02/2012 - it was highlighted that some of the seach phrases used towards the end of this article were not returning the expected results - that was down to me making assumptions about which words would be stemmed - these examples have been updated.

This tutorial will take you through an end-to-end implementation of a simple web site to manage a list of employees. LIFTI will be used to perform full text searching of plain text information associated to the employees.

Entity Framework Code First: "The path is not valid. Check the directory for the database"

Mon, 27 Jun 2011 00:00:00 +0000

If you create a new MVC application and try to go down the Code First with SQL Server Compact route, you might encounter this error when you first start the application:

The path is not valid. Check the directory for the database.**[ Path = …\WebSample\App_Data\YourDatabase.sdf ]

This error might be a surprise because by default the code first approach should create the database for you if it doesn’t already exist.

LIFTI XmlWordSplitter

Fri, 10 Jun 2011 00:00:00 +0000

The XmlWordSplitter is a new word splitter class in the latest release of LIFTI. I created it mainly because it was required for the persisted index sample, but it seemed too useful to keep out of the core framework.

At a very high level the XmlWordSplitter just enumerates words contained within elements in a piece of XML text. This means that element names, attributes and their associated values will not be indexed. For example, consider the following XML:

Changes to the LIFTI API

Wed, 08 Jun 2011 00:00:00 +0000

This post relates to the breaking changes between version 0.4 and 0.5 of LIFTI. LIFTI is a full-text indexing library for .NET - find out more on its CodePlex site.

The latest release of LIFTI has several breaking changes that will affect you, so I wanted to take some time to explain not only what they are, but why I made them. I’ll start with the what, then move onto the why.

Debugging "The agent process was stopped while the test was running"

Mon, 25 Apr 2011 00:00:00 +0000

I’ve encountered the unhelpful “The agent process was stopped while the test was running” MSTest error result a couple of times recently, and I thought that I’d share a few of my findings and approaches to debugging the unit tests that cause them.

The MSTest “Error” Result

In my experience, the Error result usually manifests itself for one of a two reasons:

A critical error occurred during the execution of the test. This might be due to something caused by the code executed by the test, for example a stack overflow error, but it may also occur when the test framework is unable to execute the test for some reason, e.g. it is unable to copy dependent files.
A test caused some code to be executed on another thread, and ** an exception occurred on that thread, not the main test one.

The first of these is easy to overcome, as I’ll show later, however the second can, under some circumstances, be much trickier to diagnose.

Using Windows Live Mesh to synchronize your draft blog posts

Tue, 12 Apr 2011 00:00:00 +0000

I use Windows Live Writer to put together all my blog posts, but I also use multiple computers. I’ll sometimes find myself writing a draft post on one computer and wanting to carry on editing it on another.

Live Writer stores draft posts in Documents\My Weblog Posts\Drafts, and in the past I’ve just manually copied these draft files from one computer to another, however it recently occurred to me that I could use Windows Live Mesh to automate this for me. I’ll show you how you can do it too.

Describing the LIFTI persistence file format

Fri, 08 Apr 2011 00:00:00 +0000

This post will break down how the data in a LIFTI persisted full text index is structured on disk. It might be a bit dry for some, so I’ve tried to spice it up as much as possible with pretty pictures!

Birds-eye view

The file is broken up into two areas, headers and page data. Each data page is is 8Kb in length and contains 1 or more entries. (The only time you might find a page that is not marked as unused and still contains 0 entries is when the index is completely empty.)

Persisting GetHashCode values is a staggeringly bad thing to do, and you should know better

Mon, 04 Apr 2011 00:00:00 +0000

The title pretty much sums up my feelings on the subject, but it probably needs a bit of context.

I’ve been doing some work for a client that relies on a 3rd party application framework (No, I’m not going to name and shame the framework!). The application is split across multiple servers and we’ve been upgrading some of them to a 64bit environment. Once we had completed the upgrade process, other parts of the application, on other servers, started breaking.

Implementing a persisted file store for LIFTI

Tue, 29 Mar 2011 00:00:00 +0000

Over a month ago I started to write a persisted file store for LIFTI. Given that I’d pretty much just finished implementing binary serialization for indexes, why would I want to do that?

Serialization vs. persistence

I wrote the serialization classes because I knew that it wasn’t always going to be appropriate to re-index all the data every time an application started up. These classes allowed for the current state of an index to be saved to and reloaded from disk. This meant that when the application exited, a developer could save what was currently in the index and reload it the next time it started. The problem for me lies in the word exited. At what point would you persist your index if you application crashed?

Problems programatically creating AppPool

Mon, 21 Mar 2011 00:00:00 +0000

I was creating an AppPool using the Microsoft.Web.Administration assembly today and kept running into this in the Application event log:

The worker process failed to initialize correctly and therefore could not be started. The data is the error.

The only “helpful” code that was provided in the event data was 57000780. Not great, but it was at least consistent.

It turns out that the ManagedRuntimeVersion property of the ApplicationPool object is case sensitive, so setting it to V4.0 just won’t cut it - it has to be v4.0. Unfortunately it won’t tell you that something is wrong if you do set it to the wrong value - it just blows up when you first try to access an application that uses it.

NotSupportedException when calling EndGetResponse in Silverlight

Fri, 18 Mar 2011 00:00:00 +0000

This one had me stumped for a little while today. I was using a WebRequest in a Silverlight 4 application to post some data to an API endpoint, and whenever I called EndGetResponse, a NotSupportedException was thrown.

To help illustrate the problem, here’s a mock-up of the code:

 1
 2using System;
 3using System.Net;
 4using System.Windows.Controls;
 5
 6namespace SilverlightApplication1
 7{
 8    public partial class MainPage : UserControl
 9    {
10        public MainPage()
11        {
12            InitializeComponent();
13
14            var request = (HttpWebRequest)WebRequest.Create("http://myapi.com");
15            request.Method = "POST";
16
17            var myPostData = new byte[10];
18            request.ContentLength = myPostData.Length;
19
20            request.BeginGetRequestStream(
21                a =>
22                {
23                    var stream = request.EndGetRequestStream(a);
24                    stream.Write(myPostData, 0, myPostData.Length);
25                    request.BeginGetResponse(this.GetResponse, request);
26                },
27                null);
28        }
29
30        private void GetResponse(IAsyncResult ar)
31        {
32            var request = (HttpWebRequest)ar.AsyncState;
33            var response = request.EndGetResponse(ar);
34            
35            // Get data from the response stream, etc.
36        }
37    }
38}

After a brief spell of head-scratching, I got to the root of the problem: the request stream wasn’t being closed before the call to EndGetResponse. This meant that as far as the WebRequest was concerned, it was still sending data to the server when I tried to get the response. A NotSupportedException is probably not the most appropriate exception to be thrown in this situation, but there you go.

Debugging bad request errors-Windows Live SDK

Wed, 02 Feb 2011 00:00:00 +0000

Important note - this code is not to be considered production quality - as always feel free to use it, but please take it with a handful of salt. In my experience working with these sorts of APIs can be a real killer if you’re not extremely careful about how you write your code.

When you’re making calls to the live.com endpoints from .NET code, you’ll probably be doing something like this:

Building a debugger visualizer for generic types

Mon, 31 Jan 2011 00:00:00 +0000

You can find the source code relating to this posthere.**

Since Visual Studio 2005 we have been able to write debugger visualizers to help us look at data in a more convenient way whilst debugging.

A while ago I needed to write a visualizer for LIFTI - the problem that I had was that the type I wanted to visualize was generic, and it’s not straightforward to write a visualizer for a generic type. I thought it would be useful to explain my approach to this solution for others to follow.

Performance tuning using Visual Studio 2010

Tue, 25 Jan 2011 00:00:00 +0000

In this post I’ll be showing you how to use Visual Studio 2010 performance analysis tools to find slow parts in your code, make changes and then verify that those fixes have actually been beneficial.

I will be analyzing the LIFTI code as of change set 54973, so if you want to you can download it and follow along, although the general principles will be the same regardless of project.

Writing multi-threaded unit tests

Sun, 16 Jan 2011 00:00:00 +0000

In my last blog post I described how I implemented the lock manager in LIFTI. This was pretty straightforward because ReaderWriterLockSlim was leveraged to do all of the really heavy lifting, but the hard part came when I wanted to unit test the code.

This post will take you through the thought and implementation process I went through to make this happen.

Test cases

The four key scenarios I wanted to test were:

Implementing thread safety in LIFTI

Tue, 11 Jan 2011 00:00:00 +0000

I’ve wanted to get a bit of thread-safety going in LIFTI for a little while now because one of the my target scenarios was for the index to be hosted in a website.

The index is already thread safe for concurrent reads, but it would definitely be a really bad thing if we started mixing concurrent writes with our reads, not least because LIFTI makes heavy use of the generic Dictionary class. (The Thread Safety section of the documentation specifically calls this out)

LIFTI-Changes ahoy

Wed, 05 Jan 2011 00:00:00 +0000

Happy new year! If anyone has been following the recent check-ins that have been happening over on the LIFTI CodePlex site will have noticed quite a bit of activity over the Christmas period. In this article, I’ll try to summarise what those changes have been and why they were introduced in the way that they were.

In short, these changes are:

Query parsing
Updatable indexes
Index serialization and de-serialization

Breaking Changes

Before I go any further, it’s probably worth noting this: the only breaking change (that comes to mind now…) is that the FullTextIndexer class has been renamed FullTextIndex. The bottom line is that it just feels better I wanted to change it before it was in too much use.

Advanced querying with LIFTI

Fri, 24 Dec 2010 00:00:00 +0000

As always, you can find the LIFTI project at its CodePlex home: http://lifti.codeplex.com.

Until now, the way in which you can query against LIFTI has been pretty basic. If you searched for “apple orange”, you would only get items back that had words starting with both apple and orange in their associated text.

For simple scenarios this is fine, but what if you wanted to search for apple or orange? What if you actually wanted both apple and orange, but they had to be near to each other? Well I have a extra special treat for you this Christmas.

401 Unauthorized when Acquiring an Access Token: Windows Live SDK

Thu, 23 Dec 2010 00:00:00 +0000

Working with other people is hard. Working with new SDK documentation is even harder, especially when it’s wrong.

If you’re following the Working with OAuth WRAP Windows Live SDK documentation and you get to the Acquiring an Access Token sample you’ll probably encounter a 401 unauthorized error when you try and read the response from https://consent.live.com/AccessToken.aspx. This is because the POST data that the sample code gets you to build up is incorrect.

LIFTI and Porter stemming

Tue, 07 Dec 2010 00:00:00 +0000

Back in the original post where I first introduced LIFTI I wrote:

LIFTI will not...:

Handle word derivatives, e.g. if “Cats” is searched for, objects containing just the word “Cat” would not be returned.

This was always something that I wanted to handle, but felt that it was better to have a simple system that actually worked than an incomplete complex system. I’ve been a bit slack in updating the LIFTI code, but this has always been at the top of my list of things to implement.

Using T4 to generate content at runtime

Fri, 19 Nov 2010 00:00:00 +0000

UPDATE 9 April 2014: The source is also available on GitHub

T4 (the Text Template Transformation Toolkit) is slowly becoming more widely known as a way to generate code to be compiled and used alongside hand-written code. Frameworks such as the Entity Framework V4 have adopted it for its code generation, allowing you to simply switch out the default class template for an alternative, e.g. POCO entity classes.

Whilst it seems to be fairly well known that T4 can be used to generate output at design time, it is less well known that you can actually use a T4 template at runtime as well. An example where you might want to do this is the generation of email content - this article will demonstrate how you might go about this.

LIFTI: Searching Pascal-cased words

Thu, 18 Nov 2010 00:00:00 +0000

This post will show how LIFTI can be adapted to index and search upon Pascal-cased words, similar to Visual Studio 2010’s Navigate To window. (Or Resharper’s Go to symbol command, if you’re so inclined)

The code for this sample can be found in the Lifti solution:* http://lifti.codeplex.com/SourceControl/list/changesets*- you’ll find the sample project in the Samples solution folder:

The way the default word splitter works is by breaking a phrase into separate words wherever whitespace characters appear - by changing this behaviour to break on changes in capitalisation, we’re pretty much all the way there:

Errors using a custom RIA authentication service (and how to resolve them)

Wed, 30 Jun 2010 00:00:00 +0000

If you’ve created your own authentication service for a Silverlight RIA application, you might encounter the following scenarios:

1) If you get the following errors:

GetUser should have returned a single user
Logout should have returned a single, anonymous user

Then the chances are your implementation of GetDefaultUser is returning null.

2) However, if you get these:

Load operation failed for query ‘GetUser’. Entity ‘User : null’ cannot be added to cache because it doesn’t have a valid identity
Load operation failed for query ‘Logout’. Entity ‘User : null’ cannot be added to cache because it doesn’t have a valid identity

Then you’re probably returning a user object that has a null Name.

Creating a lightweight in-memory full text indexer

Fri, 29 Jan 2010 00:00:00 +0000

Introduction

SQL Server provides a really powerful full text index feature whereby you can run queries along the lines of “find me comments that contain the words ‘success’ and ‘happy’”. That’s all well and good when you are using SQL Server to retrieve data, but what do you do if you’re using some other data store, e.g. SQL Server Compact, a flat file, or even a set of .NET objects, and need to do something similar? In this sort of situation it would be helpful to be able to construct a searchable object model from your data, whatever that may be.

Using a recursive CTE to read the root parent id of a hierarchical table

Tue, 08 Dec 2009 00:00:00 +0000

Note that this post could be considered the second part in my previously incredibly short series of 1 posts: Good Uses for SQL Server 2005 Common Table Expressions - previous entries being:

Ok, so the title of the post is a bit of a mouthful - sorry about that. I was asked this as a question today, and as it had been a little while since I had looked at CTEs I thought it would be a good exercise to sit down and work it out.

How to determine the version of IIS

Mon, 09 Mar 2009 00:00:00 +0000

It took me far too long to work this out; I needed to know whether or not it was safe to try and set the ManagedPipelineMode property on an AppPool, and I figured the best way to do it would be to check the current IIS version and if it was 7.0 or above. The code to get the current version is straightforward, once you know the names of the properties to read:

Creating MSBuild XSD schemas for your custom tasks

Mon, 08 Dec 2008 00:00:00 +0000

Update 12/10/2012 - Since the LSS website is no longer active, I’ve moved the download to this site.

I’ve just uploaded a little utility onto our website herethe downloads section on this site that should help those developers that write their own MSBuild tasks.

One of the nice features that’s a little hidden in Visual Studio is its ability to provide IntelliSense and auto-completion for XML files based on the schemas that they reference, as long as the reference XSDs are included in {ProgramFiles}\{MicrosoftVisualStudioFolder}\Xml\Schemas\1033. MSBuild scripts are XML, and as such it’s possible to provide information about custom tasks that you’ve written - the only problem is that whilst writing XSD schemas isn’t exactly difficult, it can be quite involved if there are a lot of tasks that you want to expose, and keeping them in sync with your code as it changes over time can be a pain.

Collapsing Visual Studio Solution Explorer to Project Definitions

Wed, 23 Jan 2008 00:00:00 +0000

Here’s a little macro I’ve just knocked up that will collapse a Visual Studio Solution to just its project definitions - put here so you can use it too and I have access to it everywhere I work!

 1
 2Sub CollapseToProjects() 
 3    Dim items As UIHierarchyItems 
 4    Dim i As Integer 
 5
 6    ' Get the root Solution node 
 7    items = DTE.ToolWindows.SolutionExplorer.UIHierarchyItems() 
 8    If items.Count > 0 Then 
 9        ' Get a pointer to all the nodes under the solution node 
10        items = items.Item(1).UIHierarchyItems() 
11
12        For i = 1 To items.Count 
13            ' Recursively collapse any expanded items 
14            CollapseItems(items.Item(i).UIHierarchyItems) 
15        Next 
16    End If 
17End Sub 
18
19Private Sub CollapseItems(ByVal items As UIHierarchyItems) 
20    Dim i As Integer 
21
22    ' Only mess with the item if it's already expanded 
23    If items.Expanded Then 
24
25        ' Recurse into the item to collapse any children 
26        For i = 1 To items.Count 
27            CollapseItems(items.Item(i).UIHierarchyItems) 
28        Next 
29
30        ' Collapse the items 
31        items.Expanded = False 
32    End If 
33End Sub

Good Uses for SQL Server 2005 Common Table Expressions (Part 1)

Fri, 11 Jan 2008 00:00:00 +0000

Previous posts in this series:

Part 0 - Introduction

Determining the top and bottom n pieces of information

in a set

This scenario involves a set that has a column with both positive and negative ranges of data. The requirement is to filter it such that the only rows returned are those with the 3 highest positive and 3 lowest negative values - basically the two extremes.

The sample data

The data I’ll be working with in this example is in a table called SampleData, which contains:

Good Uses for SQL Server 2005 Common Table Expressions (Part 0)

Thu, 10 Jan 2008 00:00:00 +0000

A significant portion of my time as a developer is taken up looking into different approaches solving problems with newer technologies. Often it feels like I’m trying to understand the solution to a problem I haven’t yet defined, but I accept this because I look upon it as adding tools to my arsenal that I can draw upon when an appropriate situation arises.

One such solution I’ve been aware of for a while now is the new Common Table Expressions (CTEs) feature and related Ranking and Windowing functions in SQL Server 2005, and I’ve recently found myself stuck with problems that are these features solve nicely. Although there are traditional tricks that work as well, usually involving cursors, Ranking and Windowing provide a very neat solution.

Determining Framework SDK Path

Mon, 06 Aug 2007 00:00:00 +0000

Something I’ve needed to do a couple of times now is programmatically work out where the the Framework SDK is installed. Each time I have to find an example from an old project, because I can never remember exactly how I did it before, so for posterity (and to save me searching again), I’m posting it up here.

Feel free to use this particular snippet however you want, but as usual, I don’t provide any warranties that it fit for purpose, etc, so use it at your own risk! Note that there’s no error handling for when the SDK is not installed, so you might want to add that in if you’re intending on using it in a fault-tolerant environment.

Easy way to enter GUIDs for WiX scripts

Thu, 20 Jul 2006 00:00:00 +0000

One of the pains of using WiX is that every component you create has to have its own unique GUID.Using the Tools/Create GUID... option from Visual Studio is one way to create a new GUID, but you have to copy and paste it into the right place in your script, which, when you have to create in the region of a trillion components, can be quite tiresome.The easiest way I’ve found of doing it is to create a custom macro, along the lines of:Sub Guid() DTE.ActiveDocument.Selection.Text =System.Guid.NewGuid.ToString End SubYou can then associate the macro to a keyboard shortcut (Tools/Options.../Keyboard), e.g. Ctrl-K,Ctrl-G.

Configuring ADAM to use SSL

Thu, 13 Jul 2006 00:00:00 +0000

I’ve wasted muchos hours trying to configure ADAM to use SSL in an attempt to use securely it as a membership provider in ASP.NET 2.0, and one of the biggest problems was the documentation I found for it. The procedures I have managed to find on the internet are either wholly inadequate or simply incorrect.I’m posting the process I’ve documented at LSS so that hopefully others can get through the whole setup a bit quicker. I’ve repeated the process several times on our QA environment running Server 2003 R2 and on two installations of XP, so I’m fairly confident that things are pretty much correct.Before I begin, there are a couple of environment assumptions that are made: