Skip to content

2005

  • 1 min read

ComponentDropper

Today I released an add-in for Visual Studio .NET 2005 that allows you to drag components onto the designer surface. It's called ComponentDropper and you can even watch a movie to know what it does and how to use it.

RazorToolboxDialog

A very good tool for screen capturing is Windows Media Encoder. It's from Microsoft and you can download it, if you have a legal version of Windows XP.

Windows Media Encoder 9 Series is a powerful tool for content producers who want to capture audio and video content using the many innovations in Windows Media 9 Series including high-quality multichannel sound, high-definition video quality, support for mixed-mode voice and music content, and more.

  • 1 min read

Unit testing with NUnit and Visual Studio 2005 (MSUnit)

On my current project we are developing a windows forms application in Visual Studio 2005. We are still using CruiseControl.NET for continuous integration and unit testing, because setting up a team foundation server would give an overhead right now.

For unit testing we like to have the nice debug and built-in features of MSUnit and the unit tests automatically tested by CruiseControl.NET through NUnit. The good thing about the two libraries, is that they work through attributes and the common Assert methods are the same.

The template we use for our unit tests, looks like: 

#if NUnit 
  using NUnit.Framework; 
#else 
  using Microsoft.VisualStudio.QualityTools.UnitTesting.Framework; 
#endif

namespace MyUnitTests { 

  [NUnit.Framework.TestFixture] 
  [Microsoft.VisualStudio.QualityTools.UnitTesting.Framework.TestClass] 
  public class MyTestClass 
  {       
    [NUnit.Framework.Test] 
    [Microsoft.VisualStudio.QualityTools.UnitTesting.Framework.TestMethod] 
    public void MyTestMethod() 
    { 

    } 
  } 
}

We migrated our project to the new Composite UI. Yes, today a new release of the cab has been released. In the unit tests of CAB I noticed they did the same trick, but with aliases: 

#if !NUNIT 
  using Microsoft.VisualStudio.TestTools.UnitTesting; 
#else 
  using NUnit.Framework; 
  using TestClass = NUnit.Framework.TestFixtureAttribute; 
  using TestMethod = NUnit.Framework.TestAttribute; 
  using TestInitialize = NUnit.Framework.SetUpAttribute; 
  using TestCleanup = NUnit.Framework.TearDownAttribute; 
#endif

namespace MyUnitTests 
{ 
  [TestClass] 
  public class MyTestClass 
  { 
    [TestMethod] 
    public void MyTestMethod() 
    { 

    } 
  } 
}
  • 1 min read

LAME is a very popular LGPL MP3 encoder. For a long time LAME version 3.90.X was recommended, now version 3.97b has been released. This version uses the -V setting, with a value from 0 (highest) till 9 (lowest) quality in VBR. More details about these settings can be found here.

Instead of lossy compressions like MP3, there are also losless codecs like FLAC (Free Losless Audio Coded). No quality is lost, but the file size is much bigger. Here are some results in applying the above settings on a regular audio cd:

Setting File size Remark
WAV 721 MB lossless, uncompressed
FLAC 405 MB losless, level 9 (highest)
LAME -b 320 163 MB lossy, CBR 320, highest possible quality
LAME -V 0 105 MB lossy, VBR
LAME -V 0 --vbr-new 102 MB lossy, VBR but another algorithm (better quality and smaller)

You can assume that with the settings used here you cannot distinguish the mp3 from the original cd. A very good resource about audio, codecs and tests is Hydrogenaudio. This graph gives a nice relationship between the file size and audio quality for the LAME encoder. Between V0 and CBR320 setting, you see the file size increases by 50%, whereas the quality does not increase as much as that.

  • 3 min read

Cube server

This year I purchased a server for persisting my data and for running applications that require intensive processing. For me it was very important to have a robust & performant way for archiving my data. Therefore I purchased a RAID card from Areca, the ARC-1120. The raid card is connected through 8 HD's of 200GB from Western Digital in RAID 5. Areca is currently one of the best RAID cards available. This page contains an extended review with benchmarks

My initial idea was to use my current ASUS A8N-SLI Deluxe motherboard, which has 2x PCI-E Express ports, and to use one port for the RAID controller. At that time it was still not possible, but now ASUS has provided a new BIOS driver which fixes the issue. After a lot of research and certainly the many chats I had with Bruno, I decided to go for a server motherboard. This is simply the most recommended way and is more robust, uses registered memory, has PCI-X ports, dual CPU, more memory slots, etc.

I wanted a server motherboard that contains dual CPU core support and featuring one or two PCI-E ports. This way I can easily upgrade in the future if it is necessary. Therefore I purchased the Tyan K8WE, which is an NForce Pro based server motherboard with 2x PCI Express x16 slots @full speed x16 lanes and has even a firewire connection.

A lot of hardware components means a large case. Therefore I decided to buy the U2-UFO case from Mountainmods. It's really a case with a lot of space and most important it can contain up to 9 HD's and it's compatible with an Extended ATX motherboard.

I am still configuring the server, but I will certainly post some benchmarks and experiences. In the mean time you can find the specs and some pictures of my server.

server1

server2

Server3

  • 1 min read

IStaySharp.WebBrowser 0.9.0.1

I updated the IStaySharp.WebBrowser control with some bug fixes.

  • DocumentText fix in IEBrowser
  • Fix of member TranslateAccelerator in IDocHostUIHandler
  • ScrollBarsEnabled fix in IEBrowserSiteBase

More information can be found on IStaySharp.

  • 1 min read

Parse versus TryParse in .NET 2.0

In .NET 2.0 you will notice that every data has among others an extra method called TryParse. TryParse and Parse are semantically the same but differ in the way they handle errors. Parse method will throw an exception if it cannot convert the string, whereas the TryParse method returns a boolean to denote whether the conversion has been successfull or not, and returns the converted value through an out parameter.

int result = 0; 
bool success = true;

string badValue = "12a45"; 
string goodValue = "1245";

try { 
  result = int.Parse(badValue); 
} 
catch { 
  success = false; 
}

Debug.Assert(success == false); 
Debug.Assert(result == 0);

success = true;

try { 
  result = int.Parse(goodValue); 
} 
catch { 
  success = false; 
}

Debug.Assert(success == true); 
Debug.Assert(result == 1245);

// int.TryParse

success = int.TryParse(badValue, out result);

Debug.Assert(success == false); 
Debug.Assert(result == 0);

success = int.TryParse(goodValue, out result);

Debug.Assert(success == true); 
Debug.Assert(result == 1245);

The reason why the TryMethod is introduced, is because exceptions are expensive. On http://www.codinghorror.com/blog/archives/000358.html you find a benchmark tool and you notice that the (default) Parse method is a lot slower.

One tip: For extensive use of string concatenation you use the StringBuilder class, for converting data types you apply the TryParse method.

  • 1 min read

Nullable types in .NET 2.0

In .NET 1.1 you cannot assign the NULL value to a value type (e.g. int, float, etc.). There are some situations where this is needed, typically in database scenarios. In .NET 2.0 there is a new type called nullable. The nullable type implements the INullableValue interface and looks like:

public interface INullableValue 
{ 
  bool HasValue { get; } 
  object Value { get; } 
}

The idea is that a nullable type combines a value (Value) of the underlying type with a boolean (HasValue) null indicator. The underlying type of a nullable type must be a value type.

Nullable<int> x = 9;

Debug.Assert(x.HasValue); 
Debug.Assert(x == 9); 
Debug.Assert(x.Value == 9); 
Debug.Assert(x.GetValueOrDefault(5) == 9);

x = null; 

Debug.Assert(x.HasValue == false); 
Debug.Assert(x.GetValueOrDefault(5) == 5);

You can also use the ? type modifier to denote a nullable type.

int? y = 9; 

Debug.Assert(y.HasValue); 
Debug.Assert(typeof(int?) == typeof(Nullable<int>));

In .NET 2.0 there is a new operator, called the null coalescing operator, ??. For example the statement x ?? y is x if x is not null, otherwise the result is y. Note that this operator also works with reference types.

int? a = null; 
int? b = 6; 

Debug.Assert((a ?? b) == b); 

a = 9; 

Debug.Assert((a ?? b) == a); 

b = null; 

Debug.Assert((a ?? b) == a);
  • 1 min read

RemotingHelper in .NET 2.0 (using generics)

RemotingHelper is a little helper class by Ingo Rammer that enables you to use interfaces to access remote objects instead of the implementation. In .NET 2.0 there are a lot of new features, and one of them are generics. Especially with the RemotingHelper we deal with types and with the GetObject method we can use generics to parameterize the method by type.

In .NET 1.1 we need to write something like

ICustomerService customerService = RemotingHelper.GetObject(typeof(ICustomerService)) as ICustomerService;

when using generics in .NET 2.0 we can simply write

ICustomerService customerService = RemotingHelper.GetObject<ICustomerService>();

No need to cast and no typeof operator! Below you find a version of the RemotingHelper using generics

using System; 
using System.Collections.Generic; 
using System.Runtime.Remoting;

public class RemotingHelper { 

  private static bool isInit; 
  private static IDictionary<Type, WellKnownClientTypeEntry> wellKnownTypes;

  public static T GetObject<T>() 
  { 
    if (!isInit) 
      InitTypeCache();

    WellKnownClientTypeEntry entry = wellKnownTypes\[typeof(T)\];

    if (entry == null) 
    { 
      throw new RemotingException("Type not found!"); 
    }

    return (T)Activator.GetObject(entry.ObjectType, entry.ObjectUrl); 
  }

  public static void InitTypeCache() 
  { 
    isInit = true; 
    wellKnownTypes = new Dictionary<Type, WellKnownClientTypeEntry>();

    foreach (WellKnownClientTypeEntry entry in RemotingConfiguration.GetRegisteredWellKnownClientTypes()) 
    { 
      if (entry.ObjectType == null) 
      { 
        throw new RemotingException("A configured type could not be found. Please check spelling"); 
      }

      wellKnownTypes.Add(entry.ObjectType, entry); 
    } 
  } 
}