I _Really_ Don't Know » .Net Technical

Random NUnit Tip

Rob — Wed, 02 Jun 2004 14:48:52 +0000

Often when writing NUnit tests I find myself wanting to output some stuff to the Console in order to make sense of a failing test. But, you don’t want the console window filling up with rubbish when the test is passing, so instead of doing this…

[Test]
public void DoesSomething()
{
string expected = “some expected result”;
object someObject = new SomeObject();
string actual = someObject.DoesSomething();
Console.WriteLine(expected);
Console.WriteLine(“—-”);
Console.WriteLine(actual);
AssertEquals(“SomeObject should do something”, expected, actual);
}

you can do this…

[Test]
public void DoesSomething()
{
string expected = “some expected result”;
object someObject = new SomeObject();
string actual = someObject.DoesSomething();
try
{
AssertEquals(“SomeObject should do something”, expected, actual);
}
catch(AssertionException)
{
Console.WriteLine(expected);
Console.WriteLine(“—-”);
Console.WriteLine(actual);
throw;
}
}

Then the Console output only shows up when the test fails. Nice.

Excel…lent

Rob — Sun, 18 Apr 2004 20:46:31 +0000

Generating an Excel file from .Net should be easy right? MS have good reason to have you using their formats as the de-facto standard and make it easy, huh.

Nope. Not really.

It’s a bit trickier than you might think.

Obviously with Office XP onwards, Excel supports XML and rendering the workbook as xml is fairly trivial, but I want to support aged machines running Excel 97. This means the BIFF binary format.

Starting with MSDN you find the obvious articles on using the Office Primary Interop Assemblies to interact with the Excel object model and create a workbook that way. Other articles out on the web suggest creating your own interop assemblies… Good Plan. I wonder why MS went to all the trouble of writing the PIAs then?

The PIA approach works and the code is simple enough, but because it’s COM Interop you get objects passed back out rather than the types you want, which means you have to cast stuff to what you’re expecting. This makes the code messier to read, it’s distracting and more importantly it moves type checking from a compile time task to a runtime task making it harder to find bugs.

The big issue, though, is performance. The interop is slow. My tests tasks were to produce a roughly 100 line spreadsheet with some basic formatting of just a few cells and then write it out to disk. That shouldn’t take more than oooh, TWENTY ONE SECONDS :-O and that’s after I’ve taken out the seven seconds it takes to construct the Excel object.

There has to be a better way, or even just another way! Which, of course, there is.

There are a handful of commercial products:

Aspose.Excel;
SyncFusion’s ExcelRW;
SoftArtisan’s ExcelWriter5.
to name just the ones I shortlisted.

And they are all pretty good. There are performance differences, with Syncfusion coming in at around one second to generate the test workbook and Aspose.Excel coming in fastest at 91mS with very little variation.

But some of the programming interfaces are quirky. ExcelWriter exposes a whole load of interesting stuff when referenced, such as a load of nums all starting with __MIDL and a load of com.sun.java.collections classes that suggest it wasn’t written entirely for .Net.

Again, Aspose worked the best for me as they chose to index the sheet, row, column and cell indices from 0, yep zero, just like everything else in C#. Syncfusion, on the other hand indexed them all from 1. :-/

But I’m still looking for a good free, open-source, C# implementation to use. I found a little VB6 version, ported to VB.Net on Planet Source Code, but it isn’t very well written; it swallows exceptions and one or two other things. It also exposes the details of BIFF8 format a little too literally for my liking. Oh, and I couldn’t get it to do formatting, but that’s probably just me being dumb.

So, for the project I’m on we’ll probably buy one, but maybe I should offer some time to koogra.

Jet Brains ReSharper

Rob — Wed, 25 Feb 2004 13:02:42 +0000

Another C# refactoring tool crossed my browser windows today…

JetBrains ReSharper The Jetbrains C# plugin for Visual Studio EAP program is open: http://www.jetbrains.net/resharper The username and password are both ‘eapuser’.

I haven’t tried it yet.

Building a simple CMS XML Placeholder

Rob — Thu, 12 Feb 2004 20:19:11 +0000

I’ve just been down to see some guys in the middle of nowhere… Beautiful little office on a deer park, with views over fields and so incredibly quiet. A company called Torchbox who are getting up-to-speed with MS CMS.

While I was there the big question was why one of their placeholders wasn’t working, which I think we figured, but I also put together a very basic XML Placeholder control to act as a base for them. I thought it would be worth dropping it up here for the record.

using Microsoft.ContentManagement.Publishing.Extensions.Placeholders;
using Microsoft.ContentManagement.WebControls;
using System.Web;
using System.Web.UI.WebControls;

namespace Foo.ContentManagementServer.Extensions
{
public class SimpleXmlPlaceholderControl : BasePlaceholderControl
{
public SimpleXmlPlaceholderControl()
{
EnableViewState = false;
}

protected Literal PresentationControl;
protected TextBox AuthoringControl;

protected XmlPlaceholder BoundXmlPlaceholder
{
get
{
return BoundPlaceholder as XmlPlaceholder;
}
}

protected override void CreatePresentationChildControls(
BaseModeContainer presentationContainer)
{
PresentationControl = new Literal();
PresentationControl.ID = “PresentationControl”;
Controls.Add(PresentationControl);
}

protected override void CreateAuthoringChildControls(
BaseModeContainer authoringContainer)
{
AuthoringControl = new TextBox();
AuthoringControl.ID = “AuthoringControl”;
Controls.Add(AuthoringControl);
}

protected override void LoadPlaceholderContentForPresentation(
PlaceholderControlEventArgs e)
{
EnsureChildControls();
PresentationControl.Text = HttpUtility.HtmlEncode(
BoundXmlPlaceholder.XmlAsString);
}

protected override void LoadPlaceholderContentForAuthoring(
PlaceholderControlEventArgs e)
{
EnsureChildControls();
AuthoringControl.Text = BoundXmlPlaceholder.XmlAsString;
}

protected override void SavePlaceholderContent(
PlaceholderControlSaveEventArgs e)
{
EnsureChildControls();
BoundXmlPlaceholder.XmlAsString = AuthoringControl.Text;
}
}
}

Download file

XP Toolset for .Net

Rob — Mon, 25 Aug 2003 12:58:23 +0000

We’ve started doing TDD and Continuous Integration a bit more formally and have brought together a toolset to support this on the .Net platform. For reference this is currently:

Visual Studio.Net – IDE
Visual SourceSafe – Configuration Management
nUnit – Unit Test Framework
CruiseControl.Net – Continuous Integration Process
nAnt – .Net Build Tool
FXCop – Coding Standards validator
DevPartner Profiler – Performance Analysis and Test Coverage

Morgan's Images

Rob — Sun, 25 May 2003 12:59:05 +0000

Morgan Skinner’s written up some nice stuff on color quantization, mapping using both a palette based approach and an octree based algorithm which is also very nice.

This follows on from work I did with him back in 2002, and adds to it.

Dynamic Image Generation

Rob — Wed, 22 May 2002 12:48:58 +0000

The .Net Framework has, like many frameworks and class libraries before it, some natty little features for drawing images and for saving or streaming them in different formats.

As part of getting to grips with C# I decided to put together some image generation routines for web based buttons, but discovered that it was not all as simple as it should be.

The main problem lies here: There are two types of image format relevant to this problem – 8 bit per pixel (8bpp) images, these use a palette of colors and each pixels byte of data is an index into that palette, hence the 256 color limit; the other type is a true color image at either 24bpp (RGB) or 32bpp (ARGB).

Diagram of 8 bit per pixel palette based image

Diagram of 24 bit per pixel true color image

The limitation is this – you can get a drawing context and, therefore, draw onto a true color image but you cannot draw onto an indexed image; you can save an indexed image as a gif with a custom palette, but a true color image is always dithered to the web palette for you.

As I want to use large blocks of solid colors that are not in the web palette I’m left with two choices… Jpeg, and have the jpeg artefacts visible on the image or gif and dither to the web palette, neither of which is acceptable.

Nice logo, showing the brand compliant and very lovely jpeg artefacts.

Nice logo, showing the rather attractive standard pattern dither to web palette.

This could be solved, you might think, by streaming them out as PNG format images. There’s a little bug in doing that though, you end up with an undefined GDI+ exception. After a little digging I found that the GDI libraries for PNG don’t like the network stream, so you have to use a memory stream instead.

using System.Drawing.Imaging;
using System.IO;

public void StreamImage(System.Web.HttpResponse Response)
{
Response.ContentType = “image/png”;
MemoryStream memoryStream = new MemoryStream();
yourBitmap.Save(memoryStream, ImageFormat.Png);
memoryStream.WriteTo(Response.OutputStream);
}

But I was disappointed with this, as often the background colors on the images, which should match the HTML background color of a CSS style were being rendered differently by the browser despite them being the same RGB value when checked with Photoshop.

So, GIF it has to be.

The end result is to use two bitmaps – one at 24 or 32 bpp to draw your image onto and then a second 8bpp bitmap the same size, with your chosen palette. I call these the canvas and the output respectively. You have to copy one to the other before streaming out the final image.

The algorithm I started with simply used GetPixel and SetPixel to iterate through the two bitmaps, but it became very obvious that the interop code between .net and GDI+ was not going to cope with that. A simple, 200×200 square image was taking several seconds to map.

A fiddle with unsafe code and pointers was needed and resulted, after much optimisation, in this.

private void CopyCanvasToOutput(Bitmap canvasBitmap,
Bitmap outputBitmap)
{
BitmapData canvasData = LockBitmap(canvasBitmap);
try
{
BitmapData outputData = LockBitmap(outputBitmap);
try
{
// Get the height and width of the image in pixels
GraphicsUnit unit = GraphicsUnit.Pixel;
RectangleF bounds = canvasBitmap.GetBounds(ref unit);
int sizeX = (int) bounds.Width;
int sizeY = (int) bounds.Height;

// Get some pointers to the data in memory
Byte* pOutputBase = (Byte*) outputData.Scan0.ToPointer();
Byte* pCanvasBase = (Byte*) canvasData.Scan0.ToPointer();
Byte* pOutputRow = pOutputBase;
Byte* pCanvasRow = pCanvasBase;
PixelDataFor8bppIndexed* pOutputPixel;
PixelDataFor32bppARGB* pCanvasPixel =
(PixelDataFor32bppARGB*) pCanvasBase;
PixelDataFor32bppARGB* pPreviousCanvasPixel =
(PixelDataFor32bppARGB*) pCanvasBase;

// Get the closest colour of the first pixel.
int paletteIndex = ClosestMatch(pCanvasPixel);

// Loop through each row
for (int y = 0; y < sizeY; y++)
{
// Set the current pixels to the start of the row
pOutputPixel = (PixelDataFor8bppIndexed*) pOutputRow;
pCanvasPixel = (PixelDataFor32bppARGB*) pCanvasRow;

// Loop through each column
for (int x = 0; x < sizeX; x++, pOutputPixel++, pCanvasPixel++)
{
if (*((int*) pPreviousCanvasPixel) != *((int*) pCanvasPixel))
{
// If the current pixel is different to
// the previous pixel then find the closest
// match and remember where we were.
paletteIndex = ClosestMatch(pCanvasPixel);
pPreviousCanvasPixel = pCanvasPixel;
}
pOutputPixel->Index = (Byte) paletteIndex;
}

// Increment the row pointers by
// the byte length of a row (Stride)
pOutputRow += outputData.Stride;
pCanvasRow += canvasData.Stride;
}
}
finally
{
outputBitmap.UnlockBits(outputData);
}
}
finally
{
canvasBitmap.UnlockBits(canvasData);
}
}

private BitmapData LockBitmap(Bitmap bitmapToLock)
{
GraphicsUnit unit = GraphicsUnit.Pixel;
RectangleF boundsF = canvasBitmap.GetBounds(ref unit);
Rectangle bounds = new Rectangle((int) boundsF.X,
(int) boundsF.Y,
(int) boundsF.Width,
(int) boundsF.Height);
return bitmapToLock.LockBits(bounds,
ImageLockMode.ReadOnly,
bitmapToLock.PixelFormat);
}

[StructLayout(LayoutKind.Sequential)]
private struct PixelDataFor32bppARGB
{
//in memory byte sequence is BGRA, i.e. backwards.
public byte blue;
public byte green;
public byte red;
public byte alpha;
}

[StructLayout(LayoutKind.Sequential)]
private struct PixelDataFor8bppIndexed
{
public byte Index;
}

Color matching was also a challenge as copying from true color to a palette you have to match RGB values to the closest entry in the palette. The algorithm I’ve produced doesn’t do any dithering or anything as the intention was to avoid any pattern or diffusion, and just map to the closest colors.

private static Hashtable _paletteHashtable = new Hashtable();

private int ClosestMatch(PixelDataFor32bppARGB* pCanvasPixel)
{
byte alpha = pCanvasPixel->alpha;
byte red = pCanvasPixel->red;
byte green = pCanvasPixel->green;
byte blue = pCanvasPixel->blue;

int index = 0;

// Check the alpha
if (alpha < 128)
{
index = 255;
}
else
{
// Look for an exact match
int key = alpha << 24 | red << 16 | green << 8 | blue;
Object paletteValue = _paletteHashtable[key];
if (paletteValue != null)
{
index = (int) paletteValue;
}
else
{
// Look for a closest match
int redDistance;
int greenDistance;
int blueDistance;
int totalDistance;
int minDistance = int.MaxValue;
int loopIndex = 0;
foreach (Color color in outputBitmap.Palette.Entries)
{
redDistance = color.R - red;
greenDistance = color.G - green;
blueDistance = color.B - blue;
// The squaring done here allows us to attach
// more importance to values further away.
totalDistance = (redDistance * redDistance) +
(greenDistance * greenDistance) +
(blueDistance * blueDistance);
if (totalDistance < minDistance)
{
minDistance = totalDistance;
index = loopIndex;
}
loopIndex++;
}
// Add it to the _paletteHashtable
// lock it first and test in case anyone else
// added the index to _paletteHashtable while
// we were still computing the closest match.
lock (_paletteHashtable)
{
if (!_paletteHashtable.ContainsKey(key))
{
_paletteHashtable.Add(key, index);
}
}
}
}
return index;
}

.Net Reflector

Rob — Wed, 06 Mar 2002 12:44:15 +0000

Morgan Skinner put me onto a very nice little toy today called .Net Reflector. Basically, it uses reflection to scan through assemblies and list the namespaces, classes, methods and properties therein. Incredibly useful for scanning through the framework classes and … Continue reading →