Question

I’m working on a client-server application (.NET 4, WCF) that must support backwards compatibility. In other words, old clients should be compatible with new servers and vice versa. As a result, our client code is littered with statements such as:

if (_serverVersion > new Version(2, 1, 3))
{
    //show/hide something or call method Foo()...
}
else
{
   //show/hide something or call method Foo2()...
}

Obviously, this becomes somewhat of a maintenance nightmare. Luckily, we’re allowed to break backwards compatibility with every minor release. When we get to a point where compatibility can be broken, I’d like to clean up the code that’s in the form of the example above.

My questions:

(1) Is there a way to easily identify code blocks such as these when they are no longer “valid”? My initial thoughts were to somehow conditionally apply an Obsolete attribute based on the assembly’s version. When we get to a new minor version, the Obsolete attribute would “kick-in”, and all of a sudden we would have several compiler warnings pointing to these code blocks… Has anyone done anything like this? Or is there a better way to manage this?

(2) I cringe every time I see hard-coded versions such as new Version(2, 1, 3). What makes things worse is that during development, we don’t know the final Version that’s being released, so the version checks are based on the current build number + 1 when the developer adds the check. Although this works, it’s not very clean. Any ideas on how this could be improved?

Thanks!

Answer 1

I would suggest at least creating a method where you can do the logic like this:

public static class ServerUtilities
{
    public static bool IsValidToRun(Version desiredVersion)
    {
        if (_serverVersion >= desiredVersion)
            return true;
        else if (/* your other logic to determine if they're in some acceptable range */)
            return true;

        return false;
    }
}

Then, use like this:

if (ServerUtilities.IsValidToRun(new Version(2, 1, 3)))
{
    // Do new logic
}
else
{
    // Do old logic
}

If you need to centralize the versions, have a static repository of features to version mapping, so that you can call:

if (ServerUtilities.IsValidToRun(ServerFeatures.FancyFeatureRequiredVersion))
{
    ...
}

public static class ServerFeatures
{
    public static Version FancyFeatureRequiredVersion
    {
        get { return new Version(2, 1, 3); }
    }
}