Visual C# 2008 Breaking Changes

1

Overload resolution

Type inference is now included on arrays of pointer types in method overload resolution.

In Visual C# 2008 and earlier, type inference causes arrays of pointer types to be excluded from the method overload resolution process. In the following code, the Visual C# 2005 compiler selects the non-generic version of Test because the generic version of Test is excluded from consideration because of its type parameter of int*[]. In Visual C# 2008, the generic version of Test is selected.

using System.Collections.Generic;

unsafe class Program
{
    static void Main()
    {
        IEnumerable<int*[]> y = null;
        Test(y); 
    }

// Selected by Visual C# 2008.
    static void Test<S>(IEnumerable<S> x) { } // Selected by Visual C# 2005.
    static void Test(object o) { } 
}

3

Nullable types and ?? expressions

Compiler now correctly evaluates expressions in which nullable variables are compared to themselves.

In the original release version of Visual C# 2008, the following code compiles and outputs "false" at run time. In Visual C# 2008 Service Pack 1, Compiler Warning (level 3) CS1718 is produced and "true" is output.

static class Program
{
    static void Main()
    {
        int? x = null;
        bool y = x == x;
        Console.WriteLine(y);
    }
}

5

Expression trees

Incorrect boxing of method expressions in expression trees no longer occurs.

In the original release version of Visual C# 2008, the following code outputs 7, 0. The line Console.WriteLine(e.Compile()(default(T))); outputs zero because S is incorrectly being boxed. In Visual C# 2008 SP1, no boxing occurs, and the program outputs 7, 7.

using System;
using System.Linq;
using System.Linq.Expressions;

class Program
{
    static void Main()
    {
        Test<S>();
    }

    static void Test<T>() where T : I
    {       
        Expression<Func<T, int>> e = x => x.SetX() + x.X;
// No boxing in SP1:
        Console.WriteLine(e.Compile()(default(T))); 
    }
}

interface I
{
    int X { get; }
    int SetX();
}

struct S : I
{
    public int X { get; private set; }
    public int SetX()
    {
        X = 7;
        return 0;
    }
}

7

Type conversions

Null literals are no longer convertible to enum values.

In the original release version of Visual C# 2008, null literals are in some cases allowed to be converted to enum values. In Visual C# 2008 SP1, Compiler Error CS1502 and Compiler Error CS1503 are produced if you try to do this, as shown in the following example.

enum MyEnum
{
    Zero = 0,
    One = 1
}

class MyClass { }

class Program
{
    static void Main(string[] args)
    {
        // Produces CS1502 and CS1503 in Visual C# 2008
        // and Visual C# 2008 SP1:
        Test(null);
        // Produces CS1502 and CS1503 in Visual C# 2008 
        // SP1 but not in Visual C# 2008:
        Test((MyClass)null);         }

    static void Test(MyEnum x)
    {
        System.Console.WriteLine(x);
    }
}

9

Attributes

CharSet.Unicode is now propagated to helper types that C# generates for fixed array fields.

The C# compiler generates helper types to encapsulate fixed arrays. In the original release version of Visual C# 2008 and earlier, the layout of the array is always ANSI, even if the StructLayout attribute specifies CharSet.Unicode. There was no way to change that in C# source code. In Visual C# 2008 SP1, whatever CharSet value is specified in the StructLayout attribute is used to construct the helper class, as shown in the following code.

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
unsafe struct Test
{
    public fixed char Chars[8];
}
class Program
{
    static void Main(string[] args)
    {

    }
}

Original release version of Visual C# 2008 MSIL:
.class sequential ansi sealed nested public beforefieldinit '<Chars>e__FixedBuffer0'
       extends [mscorlib]System.ValueType
{
  // ... 
} // end of class '<Chars>e__FixedBuffer0'

Visual C# 2008 SP1 MSIL:
.class sequential unicode sealed nested public beforefieldinit '<Chars>e__FixedBuffer0'
       extends [mscorlib]System.ValueType
{
  // . . . 
} // end of class '<Chars>e__FixedBuffer0'

11

Standard query operators

Queries over non-generic collections now use standard C# cast semantics.

In LINQ query expressions over non-generic collections such as System.Collections.ArrayList, the from clause of the query is rewritten by the compiler to include a call to the Cast<T> operator. Cast<T> converts all element types to the type specified in the from clause in the query. In addition, in the original release version of Visual C# 2008, the Cast<T> operator also performs some value type conversions and user-defined conversions. However, these conversions are performed by using the System.Convert class instead of the standard C# semantics. These conversions also cause significant performance issues in certain scenarios. In Visual C# 2008 SP1, the Cast<T> operator is modified to throw an InvalidCastException for numeric value type and user-defined conversions. This change eliminates both the non-standard C# cast semantics and the performance issue. This change is illustrated in the following example.

using System;
using System.Linq;

class Program
{
    public struct S { }
    static void Main()
    {
        var floats = new float[] { 2.7f, 3.1f, 4.5f };
        var ints = from int i in floats 
                   select i;

// Visual C# 2008 SP1 throws InvalidCastException. 
        foreach (var v in ints) 
            Console.Write("{0} ", v.ToString());

        // The original release version of Visual C# 2008
        // compiles and outputs 3 3 4
    }
}

12

Type conversions

Conversion of any constant expression with a value of zero to enum is now allowed.

A literal 0 is implicitly convertible to any enum type. In Visual C# 2005 and earlier versions of the compiler, there are also some constant expressions that evaluate to 0 that can implicitly convert to any enum type, but the rule that determines which of these expressions are convertible is unclear. In Visual C# 2008, all constant expressions that are equal to 0 can be implicitly converted to any enum type.

This could cause some changes in the behavior of existing code, such as method overload resolution that relies on the absence of this implicit conversion. The following code compiles successfully on Visual C# 2005 and earlier compilers, resolving the method invocation on the short value only to the int overload. In Visual C# 2008, this invocation is ambiguous because the short value is also implicitly convertible to E. In Visual C# 2008, the behavior is changed to allow the conversion of any constant expression that evaluates to zero.

public enum E
{
    Zero = 0,
    One = 1,
} 

class A
{
    public A(string s, object o)
    { System.Console.WriteLine("{0} => A(object)", s); } 

    public A(string s, E e)
    { System.Console.WriteLine("{0} => A(Enum E)", s); }
} 

class B
{
    static void Main()
    {
        A a1 = new A("0", 0);
        A a2 = new A("1", 1);
        A a3 = new A("(int) E.Zero", (int) E.Zero);
        A a4 = new A("(int) E.One", (int) E.One);
    }
}
Visual C# 2005 output:
0 => A(Enum E)
1 => A(object)
(int) E.Zero => A(object)
(int) E.One => A(object)

Visual C# 2008 output:
0 => A(Enum E)
1 => A(object)
(int) E.Zero => A(Enum E)
(int) E.One => A(object)

14

Type errors

A new warning about the use of a reference type member in a struct has been added.

Definite assignment rules for structs require that either the struct be set to an existing instance of its type or that each of its members be assigned to before it is referenced. In Visual C# 2005, no warning or error is produced when an unassigned reference type member of a struct is used. In Visual C# 2008, Compiler Warning (level 1) CS1060 is produced, as shown in the following example.

public class U { public int i;}
public struct T { public U u;}

class Program
{
    static void Main()
    {
        T t;
// Produces CS1060:    
        t.u.i = 0; 
    }
}

16

Overflow checking

Out-of-bounds conversions to long now produce the correct compiler error.

In Visual C# 2005, the following code does not produce a compiler error. In Visual C# 2008, it produces Compiler Error CS0031.

class Conversion 
{
    static void Main() 
    {
        long l2 = (long) 9223372036854775808M; //CS0031 
    }
}

18

Side effects are now preserved in null coalescing expressions.

Definite assignment and the ?? operator.

In Visual C# 2005, in certain scenarios, the side effects on the left-hand side of a null coalescing expression are not preserved. In such cases, the second Console.WriteLine statement in the following example produces an incorrect compiler error stating that b is unassigned. In Visual C# 2008, the same code compiles correctly without an error.

static void Main()
{
    int? a, b;
    a = null;
    Console.WriteLine((b = null) ?? 17);
    // No error in Visual C# 2008:
    Console.WriteLine(a + b);  
}

20

Base classes and interfaces

Class construction now ignores explicit implementations of the same interface members in base classes.

In Visual C# 2005, when a class does not provide an implementation for an interface member, the compiler substitutes base class implementations even if they are declared as explicit interface implementations. This behavior is not in compliance with the European Computer Manufacturers Association (ECMA) specification. Visual C# 2008 correctly implements the specification. In the following example, Visual C# 2005 prints "B.Test". Visual C# 2008 correctly prints "A.Test" and ignores the Test method in class B because it is an explicit interface implementation.

using System;

interface ITest
{
    string Test { get; }
    string Test2 { get; }
}

class A : ITest
{
    public string Test { get { return "A.Test"; } }
    public string Test2 { get { return "A.Test2"; } }
}
class B : A, ITest
{
    string ITest.Test { get { return "B.Test"; } }
    string ITest.Test2 { get { return "B.Test2"; } }
}

class C : B, ITest
{
    string ITest.Test2 { get { return "C.Test2"; } }
}

class Program
{
    static void Main()
    {
        C c = new C();
        Console.WriteLine(c.Test); 
// Visual C# 2008: "A.Test"
    }
}

22

Build errors

Use of the /pdb compiler option without /debug now produces an error.

In Visual C# 2005, no warning or error is displayed when you specify the /pdb option but not the /debug option. Visual C# just creates a Release build without generating the .pdb file. In the original release version of Visual C# 2008, if you specify /pdb without also specifying /debug, the compiler displays Compiler Error CS2036.

24

Overflow checking

Constant decimal to integral conversions now produce a different compiler error.

In Visual C# 2005, the following code would produce Compiler Error CS0133: "The expression being assigned to 'b' must be constant."

const byte b = unchecked((byte)256M);

In Visual C# 2008, Compiler Error CS0031 is produced: "Constant value '256M' cannot be converted to a 'byte'." Note that the error is produced even if the unchecked modifier is applied.

26

Type errors

An error is now produced when a static type is used as a parameter in a delegate or in a lambda expression.

In Visual C# 2005, no error is produced if a static type is used as a parameter to a delegate or anonymous method. Static types cannot be used as the types of method parameters because they cannot be instantiated. The Visual C# 2005 version of the compiler allows static types as parameter types within delegates and anonymous method declarations. If you pass null as the parameter, such delegates can be invoked. In Visual C# 2008, error Compiler Error CS0721 is produced if a static type is used as a parameter to a delegate or anonymous method, as shown in the following example.

public static class Test { }
public class Gen<T> { }

// Produces CS0721:
delegate int D(Test f); 

public class TestB
{
    public static void Main()
    {
        D d = delegate(Test f) { return 1; };
    }
}

28

Overload resolution

An error is now produced when ambiguous overload resolution occurs on anonymous methods.

Method invocations on overloaded methods must be resolved by the compiler to determine which specific overload to invoke. When an invocation’s parameter type is partially inferred, the specific overload to invoke can become ambiguous. This causes a compiler error.

In the case of an anonymous method being passed as a delegate parameter, the anonymous method’s delegate type is partially inferred. This can lead to ambiguity when the compiler is selecting the correct overload.

In Visual C# 2005, the compiler does not always produce an error when there is no single best overload for an anonymous method. In Visual C# 2008, Compiler Error CS0121 is produced, as shown in the following example.

class Program
{

    static int ol_invoked = 0;

    delegate int D1(int x);
    delegate T D1<T>(T x);
    delegate T D1<T, U>(U u);

    static void F(D1 d1) { ol_invoked = 1; }
    static void F<T>(D1<T> d1t) { ol_invoked = 2; }
    static void F<T, U>(D1<T, U> d1t) { ol_invoked = 3; }

    static int Test001()
    {
// Produces CS0121:
        F(delegate(int x) { return 1; });         if (ol_invoked == 1)
            return 0;
        else
            return 1;
    }

    static int Main()
    {
        return Test001();
    }
}

30

Overload resolution

A warning is now produced when overload resolution candidate methods vary by only ref or out.

In Visual C# 2005, when the C# compiler performs overload resolution on generic types, it does not verify whether the type arguments will cause the candidate methods to vary by only ref or out. As a result, the choice of methods is left to the common language runtime (CLR) at run time, and it just selects the first method in the list. In Visual C# 2008, Compiler Warning (Level 1) CS1956 is produced when the compiler detects that two candidate methods for overload resolution will vary by only ref or out. This condition is illustrated in the following example.

using System;
class Base<T, S>
{
// Produces CS1956:
    public virtual void Test(out T x) 
    {
        Console.WriteLine("Test(out T x)");
        x = default(T);
    }
    public virtual void Test(ref S x)
    {
        Console.WriteLine("Test(ref T x)");
    }
}

interface IFace
{
    void Test(out int x);
}

class Derived : Base<int, int>, IFace
{
    static void Main()
    {
        IFace x = new Derived();
        int y;
        x.Test(out y);
    }
}

July 2008

Added topic.

SP1 feature change.