C# LANGUAGE SPECIFICATION

18.13 Versioning

2Versioning is the process of evolving a component over time in a compatible manner. A new version of a

3component is source compatible with a previous version if code that depends on the previous version can,

4when recompiled, work with the new version. In contrast, a new version of a component is binary

5compatible if an application that depended on the old version can, without recompilation, work with the new

6version.

7Most languages do not support binary compatibility at all, and many do little to facilitate source

8compatibility. In fact, some languages contain flaws that make it impossible, in general, to evolve a class

9over time without breaking at least some client code.

10As an example, consider the situation of a base class author who ships a class named Base. In the first

11version, Base contains no method F. A component named Derived derives from Base, and introduces

12an F. This Derived class, along with the class Base on which it depends, is released to customers, who

13deploy to numerous clients and servers.

14// Author A

15namespace A

16{

19}

20}

21// Author B

22namespace B

23{

29}

30}

31So far, so good, but now the versioning trouble begins. The author of Base produces a new version, giving it

32its own method F.

33// Author A

34namespace A

35{

41}

42}

43This new version of Base should be both source and binary compatible with the initial version. (If it weren’t

44possible to simply add a method then a base class could never evolve.) Unfortunately, the new F in Base

45makes the meaning of Derived’s F unclear. Did Derived mean to override Base’s F? This seems unlikely,

46since when Derived was compiled, Base did not even have an F! Further, if Derived’s F does override

47Base’s F, then it shall adhere to the contract specified by Base—a contract that was unspecified when

48Derived was written. In some cases, this is impossible. For example, Base’s F might require that overrides

49of it always call the base. Derived’s F could not possibly adhere to such a contract.

50C# addresses this versioning problem by requiring developers to state their intent clearly. In the original

51code example, the code was clear, since Base did not even have an F. Clearly, Derived’s F is intended as a

52new method rather than an override of a base method, since no base method named F exists.

53If Base adds an F and ships a new version, then the intent of a binary version of Derived is still clear—

54Derived’s F is semantically unrelated, and should not be treated as an override.

48

C# LANGUAGE SPECIFICATION

1qualified name from different assemblies, a situation that arises when types are independently given the

2same name, or when a program needs to reference several versions of the same assembly. Extern aliases

3make it possible to create and reference separate namespace hierarchies in such situations.

4Consider the following two assemblies:

5Assembly a1.dll:

6namespace N

7{

9public class B {}

10}

11Assembly a2.dll:

12namespace N

13{

15public class C {}

16}

17and the following program:

18class Test

19{

23}

24A command-line compiler might allow compilation of this program with a command-line something like

25this:

26csc /r:a1.dll /r:a2.dll test.cs

27where the types contained in a1.dll and a2.dll are all placed in the global namespace hierarchy, and an

28error occurs because the type N.B exists in both assemblies. With extern aliases, it becomes possible to place

29the types contained in a1.dll and a2.dll into separate namespace hierarchies.

30The following program declares and uses two extern aliases, X and Y, each of which represent the root of a

31distinct namespace hierarchy created from the types contained in one or more assemblies.

32extern alias X;

33extern alias Y;

34class Test

35{

39Y::N.C c;

40}

41The program declares the existence of the extern aliases X and Y, but the actual definitions of the aliases are

42external to the program. A command line compiler can enable the definition of the extern aliases X and Y

43such that the extern alias X is the root of a namespace hierarchy formed by the types in a1.dll and Y is the

44root of a namespace hierarchy formed by the types in a2.dll. A compiler might enable the above example

45with a command-line like:

46csc /r:X=a1.dll /r:Y=a2.dll test.cs

47The identically named N.B classes can now be referenced as X.N.B and Y.N.B, or, using the namespace

48alias qualifier, X::N.B and Y::N.B. An error occurs if a program declares an extern alias for which no

49external definition is provided.

50An extern alias can include multiple assemblies, and a particular assembly can be included in multiple extern

51aliases. For example, given the assembly

50