breaking changes in .NET
I would like to gather as much information as possible regarding API versioning in .NET/CLR, and specifically how API changes do or do not break client applications. First, let's define some terms:
API change - a change in the publicly visible definition of a type, including any of its public members. This includes changing type and member names, changing base type of a type, adding/removing interfaces from list of implemented interfaces of a type, adding/removing members (including overloads), changing member visibility, renaming method and type parameters, adding default values for method parameters, adding/removing attributes on types and members, and adding/removing generic type parameters on types and members (did I miss anything?). This does not include any changes in member bodies, or any changes to private members (ie we do not take into account Reflection).
Binary-level break - an API change that results in client assemblies compiled against older version of the API potentially not loading with the new version. Example: changing method signature, even if it allows to be called in the same way as before (ie: void to return type / parameter default values overloads).
Source-level break - an API change that results in existing code written to compile against older version of the API potentially not compiling with the new version. Already compiled client assemblies work as before, however. Example: adding a new overload that can result in ambiguity in method calls that were unambiguous previous.
Source-level quiet semantics change - an API change that results in existing code written to compile against older version of the API quietly change its semantics, eg by calling a different method. The code should however continue to compile with no warnings/errors, and previously compiled assemblies should work as before. Example: implementing a new interface on an existing class that results in a different overload being chosen during overload resolution.
The ultimate goal is to catalogize as many breaking and quiet semantics API changes as possible, and describe exact effect of breakage, and which languages are and are not affected by it. To expand on the latter: while some changes affect all languages universally (eg adding a new member to an interface will break implementations of that interface in any language), some require very specific language semantics to enter into play to get a break. This most typically involves method overloading, and, in general, anything having to do with implicit type conversions. There doesn't seem to be any way to define the "least common denominator" here even for CLS-conformant languages (ie those conforming at least to rules of "CLS consumer" as defined in CLI spec) - though I'll appreciate if someone corrects me as being wrong here - so this will have to go language by language. Those of most interest are naturally the ones that come with .NET out of the box: C#, VB and F#; but others, such as IronPython, IronRuby, Delphi Prism etc are also relevant. The more of a corner case it is, the more interesting it will be - things like removing members are pretty self-evident, but subtle interactions between eg method overloading, optional/default parameters, lambda type inference, and conversion operators can be very surprising at times.
A few examples to kickstart this:
Adding new method overloads
Kind: source-level break
Languages affected: C#, VB, F#
API before change:
public class Foo
{
public void Bar(IEnumerable x);
}
API after change:
public class Foo
{
public void Bar(IEnumerable x);
public void Bar(ICloneable x);
}
Sample client code working before change and broken after it:
new Foo().Bar(new int[0]);
Adding new implicit conversion operator overloads
Kind: source-level break.
Languages affected: C#, VB
Languages not affected: F#
API before change:
public class Foo
{
public static implicit operator int ();
}
API after change:
public class Foo
{
public static implicit operator int ();
public static implicit operator float ();
}
Sample client code working before change and broken after it:
void Bar(int x);
void Bar(float x);
Bar(new Foo());
Notes: F# is not broken, because it does not have any language level support for overloaded operators, neither explicit nor implicit - both have to be called directly as op_Explicit and op_Implicit methods.
Adding new instance methods
Kind: source-level quiet semantics change.
Languages affected: C#, VB
Languages not affected: F#
API before change:
public class Foo
{
}
API after change:
public class Foo
{
public void Bar();
}
Sample client code that suffers a quiet semantics change:
public static class FooExtensions
{
public void Bar(this Foo foo);
}
new Foo().Bar();
Notes: F# is not broken, because it does not have language level support for ExtensionMethodAttribute , and requires CLS extension methods to be called as static methods.
Changing a method signature
Kind: Binary-level Break
Languages affected: C# (VB and F# most likely, but untested)
API before change
public static class Foo
{
public static void bar(int i);
}
API after change
public static class Foo
{
public static bool bar(int i);
}
Sample client code working before change
Foo.bar(13);
Adding a parameter with a default value.
Kind of Break: Binary-level break
Even if the calling source code doesn't need to change, it still needs to be recompiled (just like when adding a regular parameter).
That is because C# compiles the default values of the parameters directly into the calling assembly. It means that if you don't recompile, you will get a MissingMethodException because the old assembly tries to call a method with less arguments.
API Before Change
public void Foo(int a) { }
API After Change
public void Foo(int a, string b = null) { }
Sample client code that is broken afterwards
Foo(5);
The client code needs to be recompiled into Foo(5, null) at the bytecode level. The called assembly will only contain Foo(int, string) , not Foo(int) . That's because default parameter values are purely a language feature, the .Net runtime does not know anything about them. (This also explain why default values have to be compile-time constants in C#).
This one was very non-obvious when I discovered it, especially in light of the difference with the same situation for interfaces. It's not a break at all, but it's surprising enough that I decided to include it:
Refactoring class members into a base class
Kind: not a break!
Languages affected: none (ie none are broken)
API before change:
class Foo
{
public virtual void Bar() {}
public virtual void Baz() {}
}
API after change:
class FooBase
{
public virtual void Bar() {}
}
class Foo : FooBase
{
public virtual void Baz() {}
}
Sample code that keeps working throughout the change (even though I expected it to break):
// C++/CLI
ref class Derived : Foo
{
public virtual void Baz() {{
// Explicit override
public virtual void BarOverride() = Foo::Bar {}
};
Notes:
C++/CLI is the only .NET language that has a construct analogous to explicit interface implementation for virtual base class members - "explicit override". I fully expected that to result in the same kind of breakage as when moving interface members to a base interface (since IL generated for explicit override is the same as for explicit implementation). To my surprise, this is not the case - even though generated IL still specifies that BarOverride overrides Foo::Bar rather than FooBase::Bar , assembly loader is smart enough to substitute one for another correctly without any complaints - apparently, the fact that Foo is a class is what makes the difference. Go figure...
上一篇: 如何在Visual Studio中使自动版本号工作
下一篇: 在.NET中打破变化