Issues with DocExplorer include:

• Load times were getting too long.
• Unlike online help, new content was not available until the next release.

Microsoft’s solution is use the browser as the only way to access the help content.  A process called the Help Agent is started to support local help if that option is taken.

Problem

This apparent stop-gap solution had several weaknesses including:

• Bookmarks only last for the session.
• No indexing capability.
• Slower, not as robust as a stand-alone application.

Solution

H3Viewer is an DocExplorer-like application written by Rob Chandler.  Download this here:

visualstudiogallery.msdn.microsoft.com

This is the solution Microsoft should have shipped with VS2010.

Tips

• Be sure to set this as the default help viewer with the H3Viewer’s menu item Options → Set Default Viewer.  This will launch it from VS2010 when you hit F1 on a symbol.
• Keep local content up to date with the Help Library Manager application.

Get-ChildItem -Include Thumbs.db -Recurse -Force | Remove-Item -Force

For the paranoid, add the -WhatIf switch at the end of the line to simulate:

Get-ChildItem -Include Thumbs.db -Recurse -Force | Remove-Item -Force -WhatIf

Also, Team System Database Edition has been updated to GDR 2. This update to the base release is commonly referred to as “Datadude”. Get that one here. More information on this release is available at Gertd’s blog.

I did encounter one issue when applying SQL Server 2008 SP1: Launching the installer immediately producted this error:

SQL Server SP1 on Windows 7

The error reads “Invoke or BeginInvoke cannot be called on a control until the window handle has been created”. This was easily resolved by relaunching the installer. This is an issue only seen in Windows 7.

Just one thing seems to be missing: Why didn’t Silverlight 3 ship with Windows 7?

1.  using statement

The most typical case when Dispose gets called by the CLR is when using exits.  This is because this using statement:

    using (var myVar = new MyType())
    { /* statements */ }

is equivalent to:

    var myVar = new MyType();
    try
    {
        /* statements */
    }
    finally
    {
        if (myVar != null)
            ((IDisposable) myVar).Dispose ();
    }

2. foreach statement

The second case when the CLR calls Dispose is when a foreach statement exits. The long style enumerator must be used in order to specify a body for the Dispose method. If the iterator methods are called without using foreach, Dispose must be explicitly called unless the user is guaranteed such a call has no effect.

In addition to these two situations where Dispose is automatically invoked by the CLR, Dispose is called by user code that conforms to the disposable pattern. It is called from objects that contain an object that implements IDisposable. Such classes should themselves derive from IDisposable and call their member’s Dispose methods from their own Dispose method.

3. Encapsulating class

When a class encapsulates any fields that are IDisposable, then that class should also be IDisposable and call Dispose for all its IDisposable fields.

4. Close method

Another situation where user code may call Dispose is from a provided Close method.

Below is template code that demonstrates the final two cases where the programmer implements calls to Dispose. This template also shows a protected overload of Dispose where the actual resource cleanup takes place.

    public class BaseDisposable : IDisposable
    {
        bool disposed;

        protected virtual void Dispose (bool isDisposing)
        {
            if (!disposed)
            {
                if (isDisposing)
                {
                    /* Cleanup managed resources here. */
                }
                /* Cleanup unmananged resources here. */
                disposed = true;
            }
        }

        public void Dispose ()
        {
            Dispose (true);
            GC.SuppressFinalize (this);
        }

        ~BaseDisposable ()
        { Dispose (false); }
    }

    public sealed class DerivedDisposable : BaseDisposable
    {
        bool disposed;
        protected override void Dispose (bool isDisposing)
        {
            if (!disposed)
            {
                if (isDisposing)
                {
                    /* Cleanup derived-class managed resources here. */
                }
                /* Cleanup derived-class unmanaged resources here. */
                disposed = true;
            }
            base.Dispose (isDisposing);
        }
    }

    public sealed class EncapsulatingDisposable : IDisposable
    {
        DerivedDisposable disposableField = new DerivedDisposable ();

        public void Close ()
        { Dispose (); }

        public void Dispose ()
        {
            /* Cleanup encapsulating-class managed resources here. */
            disposableField.Dispose ();
        }
    }

1. Write the test.
2. Confirm test failure (red).
3. Minimally code the target of the test.
4. Confirm test success (green).

This sequence has a flaw.  At step 2, there is often at least one missing method that the test must invoke.  Without such a method, the test won’t compile and so the test failure of step 2 cannot be confirmed.  Therefore, one more step should be added before step 1:

• Write any necessary method stubs that simply throw a NotImplementedException.

This keeps the code always compiling.  Compiling code is a good thing.

• Implemented generic IEquatable interface on all classes.
• Implemented proper null tests for comparison operators.

Combinatorics are great for software testing.  Get it now at:

http://kwcombinatorics.codeplex.com

Binary and documentation files are available on the releases tab.  All source files required to build the project are available on the source tab.

KwCombinatorics provide 3 different ways of generating ordered lists of combinations of numbers:

1. Pick-combinations (Combination class).
2. Permutations (Permutation class).
3. Cartesian products (Product class).

For more information on each combinatoric, see:

1. http://en.wikipedia.org/wiki/Combination
2. http://en.wikipedia.org/wiki/Permutation
3. http://en.wikipedia.org/wiki/Cartesian_product

However it does have some issues.  The subversion adapter seems to go down a lot.  There is a lot of waiting a couple hours, and then it works.  Sometimes the wait can be a couple of days.  On the other hand, the support contacts  are really great.

Also, my projects don’t show up in google.  Even googling on the title won’t get a hit.  I see in the forums that there is work to be done with SEO (search engine optimization).

If the reliability issues don’t sort out, google code looks like a good alternative. In fact, the web site has been down for at least an hour as I type.

Test driven development takes a lot of coding just to test.

Below is my version.  A trivial wrapper method may be written to get a specific value.

using System;
using System.Collections.Generic;

namespace Fibonacci
{
    class Program
    {
        static public IEnumerable<int> Fibonacci
        {
            get
            {
                int current = 0;
                int next = 1;

                for (; ; )
                {
                    yield return current;
                    int previous = current;
                    current = next;
                    next = previous + current;
                }
            }
        }

        static void Main ()
        {
            foreach (int n in Fibonacci)
                Console.WriteLine (n);
        }
    }
}