I decided that it might be nice to see counts of the number of objects that Unity is creating for each type, to confirm that my lifetime configuration is optimal.  It turned out to be straightforward to do this with a Unity extension.

Here’s how the extension is used.  First, the extension is added to the container:

    var objectCounterExtension = new ObjectCounterExtension();
    container.AddExtension(objectCounterExtension);

At application shutdown a list of types and their associated instance counts can be output like this:

    IDictionary<Type,int> objectCounts = objectCounterExtension.ObjectCounts;

    foreach (var objectCount in objectCounts.OrderBy(oc => oc.Value))
    {
        Type type = objectCount.Key;
        int count = objectCount.Value;
        Console.WriteLine("{0}: {1}", type, count);
    }

The extension is quite simple, once you know how:

    class ObjectCounterExtension : UnityContainerExtension
    {
        ObjectCounterStrategy objectCounterStrategy;

        protected override void Initialize()
        {
            objectCounterStrategy = new ObjectCounterStrategy();
            Context.Strategies.Add(objectCounterStrategy, UnityBuildStage.Creation);
        }

        public IDictionary<Type, int> ObjectCounts
        {
            get { return objectCounterStrategy.ObjectCounts; }
        }
    }

    class ObjectCounterStrategy : IBuilderStrategy
    {
        Dictionary<Type, int> objectCounts = new Dictionary<Type,int>();

        public void PostBuildUp(IBuilderContext context)
        {
            IBuildKey buildKey = context.BuildKey as IBuildKey;
            if (buildKey == null)
                return;

            Type type = buildKey.Type;

            lock (objectCounts)
            {
                int count;
                if (objectCounts.TryGetValue(type, out count))
                {
                    objectCounts[type] = count + 1;
                }
                else
                {
                    objectCounts[type] = 1;
                }
            }
        }

        public Dictionary<Type, int> ObjectCounts
        {
            get
            {
                lock (objectCounts)
                {
                    return new Dictionary<Type, int>(objectCounts);
                }
            }
        }

        public void PostTearDown(IBuilderContext context) {}
        public void PreBuildUp(IBuilderContext context) {}
        public void PreTearDown(IBuilderContext context) {}
    }

In theory it shouldn’t matter to the client whether the server is 32-bit or 64-bit – everything is out-of-process so there is no compatibility issue.   But I could see that COM was refusing to allow my client to connect to the running 64-bit server process, and instead was trying to launch a new server process (which was failing because I don’t allow that).

I have seen this type of problem many times before with COM, and it’s almost always due to security configuration – specifically the ‘run as’ configuration of the server.   So I spent a lot of time investigating that, but it turned out to be something much simpler.  Since Windows 2003 SP1, COM has a rule on x64 that if a 32-bit client CoCreates an out-of-proc server, COM will try to connect to a 32-bit server.  If the client is 64-bit, COM will try to connect to a 64-bit server.  So in my case, COM could see that the 64-bit server was running, but because the client was 32-bit it decided to launch a new (hopefully 32-bit) server process to service the request.

Fortunately there are two easy ways around the problem.  The first option is to modify the client to specify  CLSCTX_ACTIVATE_64_BIT_SERVER in the CoCreateInstance call.  The other (probably better) option is to add a PreferredServerBitness flag to the AppID registry entry for the server.

CLSCTX_ACTIVATE_64_BIT_SERVER is described here, and PreferredServerBitness here.

[Note that these instructions only apply to the K20D.   Other Pentax and Samsung cameras also have a debug mode, but the instructions are slightly different for each camera – see the end of the post for links.]

Step 1: Create a text file called MODSET.442 in the root of your SD card.   The file should contain the following single line:

[OPEN_DEBUG_MENU]

You can use any plain text editor, for example Windows Notepad.  Make sure that the file is called MODSET.442 and not MODSET.442.txt

Step 2: Put the SD card into the camera but leave the card door open.

Step 3: Hold down the Menu button and turn on the camera.  Keep holding down the Menu button until the debug menu appears.

Step 4:  Close the SD card door.

Step 5: To enable debug mode, press the right arrow to change Debug Mode from DIS to EN, then press the OK button.

Step 6: Press the MENU button to get to the standard camera menu.   (If nothing happens, make sure you have closed the SD card door.   If necessary, turn the camera off and on again after closing the door.)

Press the right arrow twice to get to the Setup menu:

This is just the standard Setup menu, but some new items have been added to the bottom.  Press the up arrow to quickly jump to the bottom to see them.

Select AF TEST then click the right arrow button.

You can now set the global focus correction.  In this screenshot the correction is set to –90 and I am about to increase it by 20 (making it –70).   Press the OK button and you are ready to take a test shot with your new AF setting.  (Some reports suggest that the camera must be restarted after setting the correction value, but it seems to apply immediately on my camera.)

Step 7:  Once you have finished playing with the AF correction, you will want to turn off the debug menu.  To do so, just turn the camera on and when the debug menu appears, set DEBUG MODE to DIS and click OK.   Your camera should now be totally back to normal.

You can leave the MODSET.442 on your SD card and then re-enable the debug menu at any time by starting from step 2.  Or you can just delete the file if you prefer.

If some part of the instructions doesn’t seem to be working, check your SD card door.   For some steps it must be open, and others it must be closed – follow the instructions exactly as above.

The debug menu is also available on several other Pentax and Samsung cameras – see the pentax-hack site for details.

Also there are detailed instructions for the Pentax K-x here, which I found very useful, even though the steps are slightly different than the K20D.

After many many test shots I think I’ve settled on –90 as my correction value.   That allows me to run my FA 50mm 1.4 with no ‘standard’ correction, and my other lenses seem happy too.

My basic requirement is to transform an end-user boolean query to an XML document.   A simple example of a query I need to parse is:

john AND (joe OR sue)

I want the generated parser to produce the following syntax tree for this query:

AND
      john
      OR
            joe
            sue

It should then be trivial to walk the tree and write the XML document I need.

An ANTLR grammar is specified in a text file with a .g extension.   Here’s how my SimpleBoolean.g starts:

grammar SimpleBoolean;

options
{
  language = CSharp2;
  output = AST;
}

I’m specifying that the generated code should be C#, and that the parser should build an abstract syntax tree (AST).

Next I specify the lexer rules:

LPAREN : '(' ;
RPAREN : ')' ;
AND : 'AND';
OR : 'OR';
WS :  ( ' ' | '\t' | '\r' | '\n') {$channel=HIDDEN;}  ;
WORD :  (~( ' ' | '\t' | '\r' | '\n' | '(' | ')' ))*;

These rules are used to turn the source text into a stream of tokens.  So parentheses and operators are special tokens, and anything else is either whitespace (which is skipped) or a word.

Finally I specify the parser rules:

expr : andexpr;
andexpr : orexpr (AND^ orexpr)*;
orexpr : atom (OR^ atom)*;
atom : WORD | LPAREN! expr RPAREN!;

This is the confusing bit.  The chain of expressions (expr –> andexpr –> orexpr) is used to signify precedence.  In this case I’ve made OR higher precedence than AND.   Also notice that andexpr (for example) does not require an AND – it is optional.  This is why the grammar supports an expr containing only an OR, even though expr is defined in terms of andexpr.

The symbol suffixes (^ on the operators and ! on the parentheses) are there to direct the AST generation.  ^ signifies a tree branch, whereas ! indicates something that should be omitted from the tree.   Anything else is a leaf.   (The parentheses are omitted because they are redundant – the structure of the tree gives the order of evaluation implicitly.)

So SimpleBoolean.g is now complete, and all that remains is to ask ANTLR to generate a C# parser from it.  I used the ANTLRWorks IDE for this, but you could use the command-line.   Once the C# files are generated, and the ANTLR .NET runtimes files added to a C# project, we’re ready to write some C#.   Here’s some code that parses a query and then walks the syntax tree and writes the nodes to the console:

class Program
{
    static void Main(string[] args)
    {
        ANTLRStringStream expression = new ANTLRStringStream("john AND (joe OR sue)");
        var tokens = new CommonTokenStream(new SimpleBooleanLexer(expression));
        var parser = new SimpleBooleanParser(tokens);

        SimpleBooleanParser.expr_return ret = parser.expr();
        CommonTree ast = (CommonTree)ret.Tree;
        Print(ast,0);
    }

    static void Print(CommonTree tree, int level)
    {
        Console.WriteLine(new string('\t', level) + tree.Text);
        if (tree.Children != null)
            foreach (CommonTree child in tree.Children)
                Print(child,level+1);
    }
}

which prints the following:

AND
        john
        OR
                joe
                sue

For a more comprehensive ANTLR tutorial, see this series of blog posts.

The first problem I hit is that the current release of Unity (1.2) has a huge bug – VirtualMethodInterceptor doesn’t work with classes that have parameters in their constructors.  Fortunately downloading and building the latest source was enough to get around that problem.

The next problem is that VirtualMethodInterceptor requires the target class to be public.  This is a common problem with code that builds derived classes at runtime.  Moq has the same issue, for example.  The standard workaround is to use the InternalsVisibleTo assembly attribute to give the dynamic assembly access to internal classes in the target assembly.   So after a little digging in the source I found the name of the dynamic assembly, and added this to my assembly:

[assembly: InternalsVisibleTo("Unity_ILEmit_DynamicClasses")]

Unfortunately this is not sufficient.  The Unity code has some validation that insists on the target class being public.  The code is in VirtualMethodInterceptor.cs:

public bool CanIntercept(Type t)
{
    Guard.ArgumentNotNull(t, "t");
    return t.IsClass &&
        (t.IsPublic || t.IsNestedPublic) &&
        t.IsVisible &&
        !t.IsSealed;
}

Removing the checks for IsPublic and IsVisible was enough to finally get everything to work correctly:

public bool CanIntercept(Type t)
{
    Guard.ArgumentNotNull(t, "t");
    return t.IsClass && !t.IsSealed;
}

Hopefully this will be fixed in time for the release of Unity 2.0.

Update: For internal interfaces with InterfaceInterceptor, you need this:

[assembly: InternalsVisibleTo("Unity_ILEmit_InterfaceProxies")]

In an unmanaged process, by default each thread has 1 Mbyte of address space reserved for its stack, but initially only a small amount of this address space is committed.   You can see this with the excellent VMMAP utility – here’s what it shows for an unmanaged x64 application:

The ‘size’ is the reserved address space – 1024k as expected.  The committed memory is 16k, which is the amount of the address space that actually has physical storage associated with it.   This can grow as required, up to the size of the reserved address space, but usually it won’t get close to that. 

The size of the reserved address space is important in the sense that we need to make sure we don’t run out – 2000 threads would be enough to max out a 32-bit process, for example.   But generally speaking it’s the committed size that has more impact – that number has to be backed by real storage, in RAM or at least the page file.

So, back to the managed process.  This is what VMMAP shows:

Reserved address space is the same as before at 1024k, but the whole thing is committed!  So each thread is using the full 1 Mbyte of physical storage, regardless of how much memory the stack actually needs.   That can’t be right, can it?   Well it seems it is, as Joe Duffy explains.

So, the bottom line is that you should think carefully about creating managed threads that are going to sit idle in your process, for example in a thread pool.   In an unmanaged process those idle threads wouldn’t be using many resources, but in a managed process they’re using a significant chunk of valuable memory.   This is even more important if you have any form of multi-process architecture, perhaps with thread pools in each process. 

If you really need a large number of long-lived threads in your managed process, consider reducing the size of the stack using the appropriate overload of the System.Threading.Thread constructor.

int size = 20000000;
int[] vector = new int[size];
Parallel.For(0, size, i => vector[i] = i % 100);

Here is the performance comparison for three scenarios:  1) running the code  in a standard (serial) for loop,  2) the .NET 4.0 Parallel.For,  and 3) my Parallel30.For.    The code is running on my dual-proc laptop.

Serial:  400ms
.NET 4.0 Parallel.For:  280ms
My Parallel30.For:  8000ms

Ouch.  My Parallel30.For is 20 times slower than a standard for loop, and nearly 30 times slower than .NET 4.0 Parallel.For.   I suppose it’s really not very surprising when you consider that my code is calling ThreadPool.QueueUserWorkItem for every iteration – that’s 20 million times in this scenario.   In some respects it’s impressive that it only takes eight seconds

So I wrote another version of the For method, which I’ve called CpuFor, targeted at this sort of scenario.   Instead of submitting a separate task to the thread pool for every iteration, it divides the iterations into ranges based on the processor count, then submits each range as a task to the thread pool.   So instead of 20 million tasks, each executing one iteration, we’ll get 2 tasks, each executing 10 million iterations.  Or on a quad-proc machine, 4 tasks each executing 5 million iterations.   Of course this assumes that on average each iteration takes a roughly equal amount of time, but that’s probably mostly true for this type of scenario.

The results are pretty good:

My Parallel30.CpuFor: 250ms

I’m now (just about) beating .NET 4.0 Parallel.For.   Though I had to go pretty specialised to do it, which makes the .NET 4.0 Parallel.For all the more impressive.   I must crack it open with Reflector some time

Anyway, here’s the code:

public static void CpuFor(int fromInclusive, int toExclusive, Action<int> action)
{
    using (var doneEvent = new ManualResetEvent(false))
    {
        int iterations = (toExclusive - fromInclusive);
        int iterationsCompleted = 0;
        Exception actionEx = null;
        int processors = Environment.ProcessorCount;

        WaitCallback iterationCode =
            (arg) =>
            {
                var range = (KeyValuePair<int, int>)arg;
                try
                {
                    int from = range.Key;
                    int to = range.Value;
                    for (int i = from; i < to; i++)
                        action(i);
                }
                catch (Exception ex)
                {
                    actionEx = ex;
                }

                int completed = Interlocked.Add(ref iterationsCompleted, range.Value - range.Key);
                if (completed == iterations)
                    doneEvent.Set();
            };

        int rangeSize = Math.Max(1, iterations / processors);
        for (int i = fromInclusive; i < toExclusive; i += rangeSize)
        {
            int from = i;
            int to = Math.Min(i + rangeSize, toExclusive);
            var range = new KeyValuePair<int, int>(from, to);
            ThreadPool.QueueUserWorkItem(iterationCode, range);
        }

        doneEvent.WaitOne();

        if (actionEx != null)
            throw new Exception("Action failed", actionEx);
    }
}

BTW If you think that the delegate invocation – action(i) – on every iteration must be a performance killer, it doesn’t seem to be.   I wrote another version that eliminates the action() call (at the expense of usability) but the performance improvement was marginal.

Parallel.For(0, 10, i => Console.WriteLine(i));

I’ve done a lot of multithreading over the years, but I must confess it’s never occurred to me to apply concurrency in this way, at the level of a simple for loop.   I’m not sure how often I’ll use it in practice, but my current work project is .NET 3.5 so I wanted to have a .NET 3.x version of Parallel.For to play with.   The code is shown below. 

Some basic tests reveal that at the extremes the performance is not as good as the .NET 4.0 version, but for more common scenarios it seems to be comparable.  

static class Parallel30
{
    public static void For(int fromInclusive, int toExclusive, Action<int> action)
    {
        using (var doneEvent = new ManualResetEvent(false))
        {
            int iterations = (toExclusive - fromInclusive);
            int iterationsCompleted = 0;
            Exception actionEx = null;

            WaitCallback iterationCode =
                (arg) =>
                {
                    try
                    {
                        action((int)arg);
                    }
                    catch (Exception ex)
                    {
                        actionEx = ex;
                    }

                    int completed = Interlocked.Increment(ref iterationsCompleted);
                    if (completed == iterations)
                        doneEvent.Set();
                };

            for (int i = fromInclusive; i < toExclusive; i++)
            {
                ThreadPool.QueueUserWorkItem(iterationCode, i);
            }

            doneEvent.WaitOne();

            if (actionEx != null)
                throw new Exception("Action failed", actionEx);
        }
    }
}

Suppose I have a ThreadPool class:

class ThreadPool
{
   public ThreadPool(int maxThreads)
   {
      ...
   }
}

I can register this in the container as follows:

container.RegisterType<ThreadPool>(new InjectionConstructor(20));

So every time the container creates an instance of ThreadPool, it will pass 20 for the maxThreads argument.   It’s not the most intuitive API, but it does the job.

However suppose I now extend my ThreadPool class to add logging, i.e.:

class ThreadPool
{
   public ThreadPool(int maxThreads, ILogger logger)
   {
      ...
   }
}

How do I modify my container registration to inject the correct ILogger instance?  Of course I could just create a Logger instance and pass it as an extra argument to InjectorConstructor, but that’s not the behaviour I want.   I want the container to resolve ILogger when the ThreadPool instance is being resolved.   Having looked through the documentation, I was coming to the conclusion that this wasn’t possible, but then I came across this post on pnpguidance.net that shows how it’s done:

container.RegisterType<ThreadPool>(new InjectionConstructor(20,typeof(ILogger)));

I suppose using typeof in this scenario makes some sense, but it’s hardly intuitive.  The API could be improved so that I don’t need to specify anything about ILogger resolution at all.   I should only have to specify explicitly the constructor arguments that cannot be resolved automatically, e.g.:

container.RegisterType<ThreadPool>().WithConstructorArg("maxThreads", 20);

1. WWSAPI for the C++ client, WCF for the .NET server, using NetTcpBinding.  (See here for details.)
2. DCOM

Option 1 was the strong favourite until Microsoft decided to play silly buggers with the redistribution rights for WWSAPI, so I’ve been forced to investigate option 2.

COM interop through loading .NET components into an unmanaged process is well documented and generally works fine, but accessing a .NET server remotely via (D)COM is not so well documented, and indeed it’s not even clear if it’s supported by Microsoft.   But it does seem to work, and it’s surprisingly simple once you discover the RegisterTypeForComClients method on the RegistrationServices class.   This is basically a wrapper for COM’s CoRegisterClassObject.

Here’s the C# server code:

[ComVisible(true)]
public interface ICalculator
{
    int Add(int x, int y);
}

[ComVisible(true)]
[ClassInterface(ClassInterfaceType.None)]
public class Calculator : ICalculator
{
    public int Add(int x, int y) { return x + y; }
}

class Program
{
    [MTAThread]
    static void Main(string[] args)
    {
        var regServices = new RegistrationServices();

        int cookie = regServices.RegisterTypeForComClients(
            typeof(Calculator),
            RegistrationClassContext.LocalServer | RegistrationClassContext.RemoteServer,
            RegistrationConnectionType.MultipleUse);

        Console.WriteLine("Ready"); Console.ReadKey();

        regServices.UnregisterTypeForComClients(cookie);
    }
}

and the C++ client code:

#import "dcomserver.tlb" no_namespace raw_interfaces_only

int _tmain(int argc, _TCHAR* argv[])
{
    CoInitializeEx(0, COINIT_MULTITHREADED);

    {
        CComPtr<ICalculator> spCalc;
        spCalc.CoCreateInstance(__uuidof(Calculator), 0, CLSCTX_LOCAL_SERVER);

        long result = 0;
        spCalc->Add(10, 20, &result);

        cout << result << endl;
    }

    CoUninitialize();
    return 0;
}

(The simplest way to generate the tlb file to #import is to run regasm /tlb DcomServer.exe)

There may well be some gotchas with this approach – I haven’t tested it thoroughly yet – but it seems a promising option if the WWSAPI licensing issues can’t be sorted out.

Suppose I have a web service that contains a Search() method that takes one of two possible types of query – a simple query or a complex query.   WCF doesn’t support xsd:choice, so I can’t use that, but it does support xsd:extension, so that should do the trick:

    [DataContract]
    [KnownType(typeof(SimpleQuery))]
    [KnownType(typeof(ComplexQuery))]
    class Query { }

    [DataContract]
    class SimpleQuery : Query { }

    [DataContract]
    class ComplexQuery : Query { }

    [ServiceContract]
    interface ISearchService
    {
        Results Search(Query query);
    }

This works ok, but it’s not quite right – the client can pass an instance of Query rather than SimpleQuery or ComplexQuery.   Query really needs to be abstract.   But does XML schema support that?   Yes, it does, through complextype’s abstract attribute.

So, problem solved.  We make Query abstract and WCF’s DataContractSerializer will add the abstract=”true” to the XSD it generates.  Except that it doesn’t.  It just ignores the fact that the Query class is abstract, which means that the client sees the class as non-abstract.  This means that the client can easily pass a Query instance to the server (which of course  causes the serializer on the server to blow up trying to create an instance of the abstract class).   Hmm.

So why doesn’t DataContractSerializer support abstract base classes?  It seems pretty simple, both in concept and implementation.   Presumably it’s deemed too OO-centric … but then why support inheritance (xsd:extension)?  

BTW There’s a StackOverflow question covering the same issue – like the poster I didn’t find any of the answers satisfactory.

This is the default look for the WPF Toolkit DataGrid:

Ugh.  The black gridlines, the white-on-blue highlight, the cramped text … it’s really not very good.   I’m no graphic designer, but I think the following simple tweaks are a significant improvement:

The gridlines are trivial to change through the DataGrid’s HorizontalGridLinesBrush and VerticalGridLinesBrush properties.   The selection highlight can be modified by setting the CellStyle property to a style containing a trigger on the IsSelected property of the DataGridCell.  Finally, I added the padding by defining a control template for the cell that has a padded border around the ContentPresenter.   As a little extra I also highlight a row when the mouse passes over it, which I find pleasing to the eye.

Here’s the complete style:

<Style x:Key="PrettierDataGridStyle" TargetType="tk:DataGrid">

    <!-- Make the border and grid lines a little less imposing -->
    <Setter Property="BorderBrush" Value="#DDDDDD" />
    <Setter Property="HorizontalGridLinesBrush" Value="#DDDDDD" />
    <Setter Property="VerticalGridLinesBrush" Value="#DDDDDD" />

    <Setter Property="RowStyle">
        <Setter.Value>
            <Style TargetType="tk:DataGridRow">
                <Style.Triggers>
                    <!-- Highlight a grid row as the mouse passes over -->
                    <Trigger Property="IsMouseOver" Value="True">
                        <Setter Property="Background" Value="Lavender" />
                    </Trigger>
                </Style.Triggers>
            </Style>
        </Setter.Value>
    </Setter>

    <Setter Property="CellStyle">
        <Setter.Value>
            <Style TargetType="tk:DataGridCell">
                <Style.Triggers>
                    <!-- Highlight selected rows -->
                    <Trigger Property="IsSelected" Value="True">
                        <Setter Property="Background" Value="Lavender" />
                        <Setter Property="BorderBrush" Value="Lavender" />
                        <Setter Property="Foreground" Value="Black" />
                    </Trigger>
                </Style.Triggers>

                <!-- Add some padding around the contents of a cell -->
                <Setter Property="Padding" Value="4,3,4,3" />
                <Setter Property="Template">
                    <Setter.Value>
                        <ControlTemplate TargetType="tk:DataGridCell">
                            <Border Padding="{TemplateBinding Padding}"
                                Background="{TemplateBinding Background}">
                                <ContentPresenter />
                            </Border>
                        </ControlTemplate>
                    </Setter.Value>
                </Setter>
            </Style>
        </Setter.Value>
    </Setter>
</Style>

I’ll leave the document on the site, so bookmarks will still work, but I’ve removed all links to it from my home page.  Interesting to see how quickly that affects the search engine ranking – after all these years it’s still number one for ‘.net faq’, in both google and bing.

The C# FAQ (for C++ programmers) looks a bit more salvageable, so I’ll keep it for now, and aim to give it an overhaul over the next few months.  

// Arrange 
var mockCache = new Mock<ICache>();
var someObject = new object();

// Act 
DoSomethingThatShouldAddObjectToCache(mockCache, someObject);

// Assert 
mockCalc.Verify( cache => cache.Insert(someObject) );

The key thing here is the use of a lambda expression in the Verify method. The lambda expression is just a convenient way to create a data structure specifying the method call we’re interested in (ICache.Insert) and the arguments we expect it to be called with (someObject). The Verify method is not going to execute the Insert method call – it’s merely going to examine the lambda expression structure to determine whether it matches a previous call on the mock (which the mock recorded in case we wanted to perform this type of verification).

The use of lambda expressions to package method names and arguments is a concise, typesafe and intellisense-friendly approach, but at first glance it appears to limit dynamic usage at run-time. An example of this problem was recently posted to the Moq discussion forum – the poster wanted to call mock.VerifyGet for every property on an interface, without having to write a VerifyGet call for every property individually.

Obviously reflection can be used to get the properties at runtime, but how do we build the appropriate lambda expression to pass to mock.VerifyGet()? Well, it turns out to be quite straightforward, using the LambaExpression class. The following code builds an expression of the type p => p.Prop, which is what we need for VerifyGet:

ParameterExpression p = Expression.Parameter(mockType, "p");
MemberExpression body = Expression.Property(p, prop);
LambdaExpression expr = Expression.Lambda(body, p);

Wrap this up in an extension method for the Mock<T> class, and we get the following VerifyAllGets() method:

public static void VerifyAllGets<T>(this Mock<T> mock) where T : class
{
    // Get a MethodInfo for the Mock<T>.VerifyGet<TProp> method.
    MethodInfo verifyGetMethod = typeof(Mock<T>).GetMethods(
        BindingFlags.Public | BindingFlags.Instance).Where(
        mi => mi.Name == "VerifyGet" &&
        mi.GetParameters().Length == 1).First();

    // Call the Mock<T>.VerifyGet method separately for each property on T.
    foreach (var prop in typeof(T).GetProperties())
    {
        // Build a lambda expression of the form p => p.Prop
        ParameterExpression p = Expression.Parameter(typeof(T), "p");
        MemberExpression body = LambdaExpression.Property(p, prop);
        LambdaExpression expr = LambdaExpression.Lambda(body, p);

        // Mock<T>.VerifyGet<TProp> must be 'closed' by specifying TProp
        var closedVerifyGetMethod = verifyGetMethod.MakeGenericMethod(prop.PropertyType);

        // Call Mock<T>.VerifyGet(expr)
        closedVerifyGetMethod.Invoke(mock, new object[] { expr });
    }
}

The VerifyAllGets() method can be used as follows:

// Arrange
var mock = new Mock<IManyProps>();

// Act
RunCodeThatGetsAllProps(mock);

// Assert
mock.VerifyAllGets();

[TestCase(CalculatorMode.Standard)]
[TestCase(CalculatorMode.Scientific)]
public void TestAdd(CalculatorMode mode)
{
   Calculator calc = new Calculator(mode);
   int res = calc.Add(10,20);
   Assert.That(res, Is.EqualTo(30));
}

This test will be executed twice, once with the calculator in ‘standard’ mode, and once with the calculator in ‘scientific’ mode.

We can take this a step further and use the Values and Range attributes to expand our set of tests:

[Test]
public void TestAdd(
   [Values(CalculatorMode.Standard, CalculatorMode.Scientific)] CalculatorMode mode,
   [Range(0,5,1)] int x,
   [Range(0,5,1)] int y
   )
{
   Calculator calc = new Calculator(mode);
   int res = calc.Add(x,y);
   Assert.That(res, Is.EqualTo(x+y));
}

This test will run a total of 72 times. The range of x and y are both 0 to 5, with an interval of 1 (i.e. the values 0,1,2,3,4,5), giving 6×6=36 tests, which are then combined with our two modes to give a total of 72 iterations.

The multiple iterations show up as separate tests in your test runner, with the names derived from the arguments used for each run, so it’s very easy to see what’s going on.

Also you may have noticed the constraint-based Assert syntax used in the examples above. I was a little unsure of it at first, but it’s growing on me. It uses a ‘fluent’ style to make the Assert more readable, so:

Assert.That(res, Is.EqualTo(x+y));

is very close to the English “Assert that res is equal to x+y”. There is a lot of debate about the merits of fluent APIs, but in this context I like it.

One constraint that really caught my eye is ‘After’. It’s useful when testing asynchronous code where you need to wait for a condition to become true. For example:

Assert.That(() => Status, Is.EqualTo("Done").IgnoreCase.After(5000, 50));

What this says is “Assert that status is ‘done’ (case insensitive) after a maximum of 5 seconds, checking every 50 ms”. The chaining of constraints like this is very readable, and the fact that relatively sophisticated constraints like After are built-in is very helpful. (I actually wrote my own version of this asynchronous wait/poll functionality recently, but I can throw it away now and use After instead.)

Finally if you derive from the AssertionHelper class, you can cut down the verbosity slightly, and re-write this Assert as:

Expect(() => Status, EqualTo("Done").IgnoreCase.After(5000,50));

Let me know if you’ve found any other cool NUnit features that I might have missed.

It’s *so* good to be back on XP. Everything is faster, my disk isn’t constantly churning, my sound works properly (no stuttering), I can login using my fingerprint reader again, and Windows Explorer works properly. The only things I miss are the sidebar (solved by installing desktop sidebar), and the search in the start menu (which I can easily live without).

Don’t get me wrong, Vista is not terrible. It’s just that for me on this particular laptop, the pain outweighs the gain. Maybe I’ll try it again in a year or two, when we’ve had a couple of service packs and the drivers are all sorted out.

Overall I have to say it’s a big disappointment. First of all, you can’t use it as an external drive, so you can’t store abitrary data on it. There is a hacky workaround circulating on the net, but it’s very kludgy. This limitation alone means I’d never recommend anyone buy one.

The second problem is the PC software (to sync your media with the Zune). The interface is truly awful. I found myself having to consult the help to work out how to do the most basic things. And the help isn’t much good either. Explaining this interface to a non-technical relative doesn’t bear thinking about. So think twice before buying one as a gift for someone.

I haven’t bothered signing up for the online marketplace stuff, so I can’t comment on that. But I read bad things about it, so I’m not really tempted to try.

As far the hardware goes, the screen is excellent – big and bright and very usable for looking at photos or even video. The controls are reasonably intuitive. The earphones are mediocre – not close to the quality of my 30 quid Sennheiser PX100 headphones. With decent headphones, the sound quality from the Zune seems fine – similar to my PC.

The software on the Zune itself is ok, but not great – the built-in themes are ugly (subjective, obviously), skipping between songs is slow, and the equalizer only has presets (no direct control over bass and treble). Oddly there seems to be hardly any noticable difference between the preset values – Rock has slightly more bass than Folk, for example, but it’s only noticeable at very high volumes.

Add in the fact that there’s no AC charger (I’m expected to take my laptop with me when travelling, obviously) and the whole Zune experience leaves a lot to be desired. I really can’t see myself using it. Probably end up on ebay. Along with quite a few others, I imagine.

BTW I have no experience with any other similar devices (e.g. IPod), so maybe they all suffer from similar problems. I doubt it, though.

Page is hidden

This feedback is not being displayed because it may identify a possible security vulnerability.

Please re-submit this feedback, and all other security-related issues, at http://www.microsoft.com/technet/security/bulletin/alertus.aspx. Please refer to our FAQ for more details.

So apparently the bug is a potential security vulnerability. Actually that makes sense, because it brings the process down. Could easily be due to a buffer overrun or similar issue that could be exploited by a bad guy.

The strange thing is that I’ve heard nothing from MS on this – not even an automated mail saying that my bug was closed. And the message on the web page isn’t too encouraging. Do they really expect me to report the problem again via a different web page, after they’ve apparently wiped my original bug report?

Perhaps I should just forget about doing the right thing and cash in?

The only problem is that there are a few bugs. I’ve reported a particularly nasty one via the MS feedback center. If you’re using virtual mode and getting apparently random crashes, check that you haven’t got any list items containing exactly 260 characters.

Here’s the command-line I’m using:

robocopy c:\src u:\src_mirror /S /MON:1 /XA:R /XD bin obj debug release build /XF *.ncb *.scc *.user *.webinfo *.suo /R:5 /W:1

The interesting switches are /MON:1, which tells Robocopy to check my source directory for changes once a minute, and /XA:R, which tells it to ignore readonly files. Because of the /XA:R, files checked into Sourcesafe are ignored. Conversely, any files I check-out become read/write and automatically get mirrored.

Obviously there are some non-readonly files and directories I don’t want to mirror, hence the /XF and /XD switches.

Been using this for a few days, and so far it seems to work great.