I’ve been working extensively on enterprise mobility projects lately. These applications integrate into large SAP based systems and when testing the system it can get very tedious to set up some temporary data from the backend. I’m also working with some not-so-technical testers that get intimidated by the Visual Studio or the SQL Server Management Studio. This led me to writing an open source project called SQL Compact Query Analyzer

Here’s some details I pulled directly off the CodePlex site

Project Description
SQL Server Compact Edition Database Query Analyzer

Features:
- Execute SQL Queries against a SQL Server Compact Edition database
- Table Data Editor to easily edit the contents of the database
- Supports SQLCE 3.0, 3.1, 3.5 and 4.0
- Execute multiple SQL queries (delimited by a semi colon ;)
- Display query result as XML
- Shrink and Compact Databases
- SDF file association with SQL Compact Query Analyzer for launching directly by opening the SDF in Windows Explorer
- Generate Schema and Data Scripts
- Display database and schema information
- Support for password protected databases

Coming Soon:
- Purge database content
- Create new database
- Create, edit, and drop tables
- Create, edit, and delete table references and indexes
- Support for SQL Server Compact Edition 2.0


Screenshots


- Displays database and schema information and executes multiple SQL queries directly


- Edit the table data directly


- Display the contents of IMAGE fields


- Performance numbers for queries


- Query errors


- Output result set as XML

Prerequisites:

- .NET Framework 4.0 

Check it out! You might find it useful!

More than a year ago, I published a project on CodePlex called SQL CE Code Generator. Unfortunately, I never managed to find the time to do some work on it and the project was set on a very long hold. A year after I suddenly really needed such a tool and decided that I should put in some hours on the project.

I'm currently working on a large enterprise project where changes to the database schema is done rather frequently, to avoid the pain of updating my data layer after every change I decided to use my code generator.

Here's some details I pulled directly off the CodePlex site.

Project Description
Contains a stand alone GUI application and a Visual Studio Custom Tool for automatically generating a .NET data access layer code for objects in a SQL Server Compact Edition database.

Features:
- Visual Studio 2008 and 2010 Custom Tool Support
- Creates entity classes for each table in the database
- Generates data access code that implements the Repository Pattern
- Generates methods for Create, Read, Update and Delete operations
- Generates SelectBy methods for every column in every table
- Generates a Purge method for every table to delete all records
- Generates Count() method for retrieving the number of records in each table
- Generates CreateDatabase() method for re-creating the database
- Generates xml-doc code comments for entities and data access methods
- Generates Entity Unit Tests
- Generates Data Access Unit Tests
- Generates .NET Compact and Full Framework compatible code

Coming Soon:
- Generate database maintenance code (clear database, shrink/compress database)
- Support for multiple versions of SQL Server Compact Edition (3.0, 3.1 3.5, 3.5 SP1, 3.5 SP2, 4.0)
- Generate unit tests for multiple unit test frameworks
- VB.NET Code Support


Screenshots:


Custom Tool


Generating Entity Classes


Generating Data Access methods that implement the Repository Pattern


Generating Entity Unit Tests


Generating Data Access Unit Tests to validate the integrity between the data layer and the actual databa

Check it out! You might find it useful too...

When installing TFS2010 (or upgrading on new hardware) with SharePoint Foundation (wss 4.0) it can not be done with the installer setting up wss. You need to install and prepare SharePoint before configuration of TFS. This can be done as described in the following blog post:

http://myalmblog.com/2010/12/20/installing-tfs2010-with-sharepoint-foundation-2010/

There is one added security setting which you might have to tweak also in SharePoint Foundation and which has been changed since wss 3.0. You need to change the security on files other than aspx to "Permissive". The default security setting is Strict, which gives you the:

 "Do you want to save this File"

when you try to access html files. E.g. the wiki.

How to change to "permissive" security is described in the following blog:

http://blog.brainlitter.com/archive/2010/05/19/sharepoint-2010-treats-pdf-and-other-file-types-as-insecure.aspx

One further note if you want to use EMC SCRUM for Team system v.3 on SharePoint Foundation 2010 and get the error:

TF249033: The site template is not available for the locale identifier (LCID). The site template name is: SCRUM

Then  apply the fix in the following post:

http://consultingblogs.emc.com/crispinparker/archive/2011/01/14/scrum-for-team-system-v3-sharepoint-2010-portal.aspx

And remember to change the powershell script line with the suggestions in the blog comments ("LiteralPath" instead of "FileName")

[Reposted from Christian Helle's Blog]

/// <summary>

/// Used for displaying a notification bubble

/// </summary>

public static class NotificationBubble

{

    /// <summary>

    /// Displays a notification bubble

    /// </summary>

    /// <param name="duration">Duration in which the notification bubble is shown (in seconds)</param>

    /// <param name="caption">Caption</param>

    /// <param name="text">Body</param>

    public static void Show(int duration, string caption, string text)

    {

        var bubble = new Notification

        {

            InitialDuration = duration,

            Caption = caption,

            Text = text

        };

        bubble.BalloonChanged += OnBalloonChanged;

        bubble.Visible = true;

    }

    private static void OnBalloonChanged(object sender, BalloonChangedEventArgs e)

    {

        if (!e.Visible)

            ((Notification)sender).Dispose();

    }

}

[Reposted from Christian Helle's Blog]

NavigationService.Navigate(new Uri("/ContentPage.xaml?index=" + index, UriKind.Relative));

<phone:PhoneApplicationPage

    x:Class="WindowsPhonePivotApplication.ContentPage"

    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

    xmlns:phone="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone"

    xmlns:shell="clr-namespace:Microsoft.Phone.Shell;assembly=Microsoft.Phone"

    xmlns:controls="clr-namespace:Microsoft.Phone.Controls;assembly=Microsoft.Phone.Controls"

    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"

    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"

    mc:Ignorable="d" d:DesignWidth="480" d:DesignHeight="768"

    FontFamily="{StaticResource PhoneFontFamilyNormal}"

    FontSize="{StaticResource PhoneFontSizeNormal}"

    Foreground="{StaticResource PhoneForegroundBrush}"

    SupportedOrientations="Portrait"  Orientation="Portrait"

    shell:SystemTray.IsVisible="True">

  <Grid x:Name="LayoutRoot" Background="Transparent">

    <controls:Pivot Name="pivot" Title="CONTENT PAGE">

      <controls:PivotItem Header="first" />

      <controls:PivotItem Header="second" />

      <controls:PivotItem Header="third" />

      <controls:PivotItem Header="fourth" />

      <controls:PivotItem Header="fifth" />

      <controls:PivotItem Header="sixth" />

    </controls:Pivot>

  </Grid>

</phone:PhoneApplicationPage>

public partial class ContentPage : PhoneApplicationPage

{

    private int pivotIndex;

    public ContentPage()

    {

        InitializeComponent();

        Loaded += delegate { pivot.SelectedIndex = pivotIndex; };

    }

    protected override void OnNavigatedTo(NavigationEventArgs e)

    {

        string value;

        if (NavigationContext.QueryString.TryGetValue("index", out value))

        {

            pivotIndex = 0;

            int.TryParse(value, out pivotIndex);

        }

    }

}

[Reposted from Christian Helle's Blog]

unsafe static BitmapSource Darken(BitmapSource image, double level)

{

    const int PIXEL_SIZE = 4;

    int height = image.PixelHeight;

    int width = image.PixelWidth;

    var bitmap = new WriteableBitmap(image);

    bitmap.Lock();

    var backBuffer = (byte*)bitmap.BackBuffer.ToPointer();

    for (int y = 0; y < height; y++)

    {

        var row = backBuffer + (y * bitmap.BackBufferStride);

        for (int x = 0; x < width; x++)

            for (int i = 0; i < PIXEL_SIZE; i++)

                row[x * PIXEL_SIZE + i] = (byte)Math.Max(row[x * PIXEL_SIZE + i] - level, 0);

    }

    bitmap.AddDirtyRect(new Int32Rect(0, 0, width, height));

    bitmap.Unlock();

    return bitmap;

}

[Reposted from Christian Helle's Blog]

unsafe static BitmapSource Brighten(BitmapSource image, double level)

{

    const int PIXEL_SIZE = 4;

    int height = image.PixelHeight;

    int width = image.PixelWidth;

    var bitmap = new WriteableBitmap(image);            

    bitmap.Lock();

    var backBuffer = (byte*)bitmap.BackBuffer.ToPointer();

    for (int y = 0; y < height; y++)

    {

        var row = backBuffer + (y * bitmap.BackBufferStride);

        for (int x = 0; x < width; x++)

            for (int i = 0; i < PIXEL_SIZE; i++)

                row[x * PIXEL_SIZE + i] = (byte)Math.Min(row[x * PIXEL_SIZE + i] + level, 255);

    }

    bitmap.AddDirtyRect(new Int32Rect(0, 0, width, height));

    bitmap.Unlock();

    return bitmap;

}

[Reposted from Christian Helle's Blog] 

unsafe static WriteableBitmap AlphaBlend(BitmapSource image1, BitmapSource image2, int alphaLevel)

{

    const int PIXEL_SIZE = 4;

    int ialphaLevel = 256 - alphaLevel;

    int height = Math.Min(image1.PixelHeight, image2.PixelHeight);

    int width = Math.Min(image1.PixelWidth, image2.PixelWidth);

    var bitmap = new WriteableBitmap(width, height, image1.DpiX, image1.DpiY, PixelFormats.Bgr32, null);

    var bitmap1 = new WriteableBitmap(image1);

    var bitmap2 = new WriteableBitmap(image2);

    bitmap.Lock();

    bitmap1.Lock();

    bitmap2.Lock();

    var backBuffer = (byte*)bitmap.BackBuffer.ToPointer();

    var bitmap1Buffer = (byte*)bitmap1.BackBuffer.ToPointer();

    var bitmap2Buffer = (byte*)bitmap2.BackBuffer.ToPointer();

    for (int y = 0; y < height; y++)

    {

        var row = backBuffer + (y * bitmap.BackBufferStride);

        var img1Row = bitmap1Buffer + (y * bitmap1.BackBufferStride);

        var img2Row = bitmap2Buffer + (y * bitmap2.BackBufferStride);

        for (int x = 0; x < width; x++)

            for (int i = 0; i < PIXEL_SIZE; i++)

                row[x * PIXEL_SIZE + i] = (byte)(((img1Row[x * PIXEL_SIZE + i] * alphaLevel) + (img2Row[x * PIXEL_SIZE + i] * ialphaLevel)) >> 8);

    }

    bitmap.AddDirtyRect(new Int32Rect(0, 0, width, height));

    bitmap2.Unlock();

    bitmap1.Unlock();

    bitmap.Unlock();

    return bitmap;

}

[Reposted from Christian Helle's Blog]

public unsafe static BitmapSource ToGrayScale(BitmapSource source)

{

    const int PIXEL_SIZE = 4;

    int width = source.PixelWidth;

    int height = source.PixelHeight;

    var bitmap = new WriteableBitmap(source);

    bitmap.Lock();

    var backBuffer = (byte*)bitmap.BackBuffer.ToPointer();

    for (int y = 0; y < height; y++)

    {

        var row = backBuffer + (y * bitmap.BackBufferStride);

        for (int x = 0; x < width; x++)

        {

            var grayScale = (byte)(((row[x * PIXEL_SIZE + 1]) + (row[x * PIXEL_SIZE + 2]) + (row[x * PIXEL_SIZE + 3])) / 3);

            for (int i = 0; i < PIXEL_SIZE; i++)

                row[x * PIXEL_SIZE + i] = grayScale;

        }

    }

    bitmap.AddDirtyRect(new Int32Rect(0, 0, width, height));

    bitmap.Unlock();

    return bitmap;

}

(Cross-posted from ploeh blog)

Recently I spent a couple of days with Thomas Jespersen who’s working towards a launch of spiir.dk – on Windows Azure. The reason I got to talk to him was to see if I could help with some performance issues he had with Azure Table Storage.

The scenario is really simple: the application needs to load all of a user’s bank transactions into memory to enable pretty advanced sorting and filtering. That sounds like a lot, but really isn’t more than approximately 200 kB of data retrieved through a single query – so: there are no 1+N problems in play here, but even so it originally took more than two seconds. That’s a bit long to wait before you can even start rendering a web page.

By tweaking his partitioning strategy and using parallel queries, Thomas managed to bring down the data retrieval time to approximately one second. Although stress testing indicated that this duration was very stable, even under load, it is still too slow. So we met to see what could be done.

Thomas had done a great job tweaking the query, so I couldn’t really suggest some sort of secret API that would make it run significantly faster. Basically, we have to deal with Azure storage being based on REST and that there are a lot of things about run-time behavior we cannot control. Apart from designing a proper partitioning strategy, we can’t add indexes to Azure Table Storage.

It was time to take a different approach.

As far as I can tell, Windows Azure is designed to be very scalable. However, just because scalability implies that you can handle an insane amount of work within acceptable time frames, it doesn’t mean that you can extrapolate it to mean that under a light load, everything will be lightning fast. That’s not the case at all.

Scalability means that performance characteristics remain stable from light to heavy load.

Consequently this means that if performance is adequate under heavy load, it will also be adequate under a light load. Azure Storage is first and foremost designed to be scalable, and as a second priority, as fast as possible.

As Thomas discovered, Azure Table Storage isn’t particularly fast.

It may be a masochistic side of me that I’m not otherwise aware of, but I actually appreciate that. It makes us reassess our most basic assumptions.

The data that Thomas needs to read isn’t particularly dynamic, so what if we take a snapshot of it? In short, we loaded all of a user’s data into memory and serialized it to Azure Blob Storage.

Loading the same data from a binary serialized Blob took only 1/6 of the time it did to load it from Table Storage.

As it turns out, Thomas doesn’t even need all the columns from the Table to populate the view, so we could even make the serialized Blob smaller yet.

At this point, however, we now have two representations of the same data: The original data in Table Storage, and a persistent cache in Blob Storage. The remaining challenge is to figure out how to keep these in sync.

This may seem like a hack, but is really represents a paradigm shift. Letting go of ACID opens up a lot of new opportunities.

Actually, I spend most of the next day trying to convince Thomas that CQRS would be the best approach, or that we could at least pick up some of the techniques from asynchronous, messaging based architectures, but that’s another story.

The morale here is that on Azure, things may be slower than you are used to, but storage is (relatively) cheap, so denormalization can save you a lot of execution time.