13. Versioning

Solving versioning issues has been a major consideration in the .NET framework. Most of these considerations apply to assemblies. There are some quite impressive capabilities such as running multiple versions of the same assembly in the same process.

The C# language prevents software failures when new versions of code (most notably the .NET libraries) are made. The C# Language Reference explains this in detail, but I've summarized the problem with a highly condensed example:

In Java, supposing we deploy a class called D which derives a class distributed with the VM, called B. Class D has a method called foo which B does not have at the time of distribution. Later, an update is made to class B, which now includes a foo method, and the new VM is installed on the computer running software which uses class D. The software using class D may malfunction because the new implementation of class B will make a virtual call to class D, performing an action with an implementation totally unintended by class B. In C#, class D's foo would have been declared without the override modifier (which expresses the programmer's intention), so the runtime knows to make Class D's foo hide Class B's foo, rather than override it.

An interesting quote from the C# reference manual was: "C# addresses this versioning problem by requiring developers to clearly state their intent". Although the use of the word override is one way to state intention, it could also be automatically generated by the compiler by checking to see if a method performs (rather than declares) an override at the time of compilation. This means you can still have Java-like languages (which don't use virtual and override keywords) and still cope with versioning correctly.

Also see Field Modifiers

14. Parameter Modifiers

"ref" parameter modifier

C# (as opposed to Java) lets you pass parameters by reference. The most obvious example to illustrate the point of this is the general purpose swap method. Unlike in C++, you must specify when calling as well as when declaring a method which takes ref parameters:

public class Test
{
    public static void Main ()
    {
        int a = 1;
        int b = 2;
        swap (ref a, ref b);
    }

    public static void swap (ref int a, ref int b) {
       int temp = a;
       a = b;
       b = temp;
    }
}

"out" parameter modifier

There is also an "out" keyword, which is a natural complement to the ref parameter modifier. While the ref modifier requires that a value is definitely assigned before passed into a method, the out modifier requires that the method's implementation definitely assigns the parameter a value before returning.

"params" parameter modifier

The params modifier may be added to the last parameter of a method so that the method accepts any number of parameters of a particular type. For example:

public class Test
{
    public static void Main () {
        Console.WriteLine (add (1, 2, 3, 4).ToString());
    }

    public static int add (params int[] array) {
       int sum = 0;
       foreach (int i in array)
           sum += i;
       return sum;
    }
}

Previous     Next