Visual C# 2008 重大更改

2

索引器

除方法之外，编译器现在对索引器和属性也生成错误 CS0466。

在 Visual C# 2008 的原始发行版及更低版本中，可以定义索引器的显式实现，其实现具有 params 参数而接口定义没有该参数。此构造违反了规范。在 Visual C# 2008 SP1 中，此构造生成编译器错误 CS0466，如下面的代码所示。

interface I
{
    int this[int[] p] { set; }
}
class Base : I
{
// Produces CS0466:
    int I.this[params int[] p]    {
        set
        {
        }
    }

}

4

迭代器中的 try-finally

更改了迭代器中包含 break 语句的嵌套 finally 块的执行方式。

在 Visual C# 2008 的原始发行版中，下面的代码两次执行外部 finally。在 Visual C# 2008 SP1 中，外部 finally 执行一次。

using System;
using System.Collections;
using System.Collections.Generic;
public class Test
{
    public static void Main()
    {
        Console.WriteLine("in main");
        foreach (int i in GetInts())
        {
            Console.WriteLine("in foreach");
            break; 
        }
    }
    static IEnumerable<int> GetInts()
    {
        Console.WriteLine("in GetInts");
        while (true)
        {
            Console.WriteLine("in while");
            try
            {
                Console.WriteLine("in outer try");
                try
                {
                    Console.WriteLine("in inner try before yield");
                    yield return 1;
                    Console.WriteLine("in inner try after yield");
                    break;
                }
                finally
                {
                    Console.WriteLine("in inner finally");
                }
            }
            finally
            {
                Console.WriteLine("in outer finally");
            }
        }
    }
}

6

对象初始值设定项

更正了对象初始值设定项中值类型的初始化。

在 Visual C# 2008 的原始发行版中，下面示例中的局部变量 b 初始化不正确，其成员 X 的值为零。在 Visual C# 2008 SP1 中，S.X 在两个 new 表达式中都正确初始化为 1。

using System;
using System.Linq;
using System.Linq.Expressions;
    class Program
    {
        static void Main()
        {
            Test<S>();
        }
        static void Test<T>() where T : I, new()
        {
            var a = new T();
            a.X = 1;
            Console.WriteLine(a.X);
            var b = new T { X = 1 };
            Console.WriteLine(b.X);
        }
    }
    interface I
    {
        int X { get; set; }
    }
    struct S : I
    {
        public int X { get; set; }
    }
// Original release version of Visual C# 2008 output: 1 0
// Visual C# 2008 SP1 output: 1 1

8

表达式目录树

无效的表达式目录树现在引发正确的异常。

在 Visual C# 2008 的原始发行版中，如果表达式目录树调用在指定类型上不存在的方法，该表达式目录树将引发 System.Security.VerificationException。在 Visual C# 2008 SP1 中将引发 System.ArgumentException，如下面的代码所示。

using System;
using System.Reflection;
using System.Linq;
using System.Linq.Expressions;
class Program
{
    public struct S { }
    static void Main()
    {
        Type t = typeof(System.Enum);
        MethodInfo m = t.GetMethod("GetTypeCode");
        ParameterExpression p = Expression.Parameter(typeof(S), "s");
        Expression<Func<S, TypeCode>> e = Expression.Lambda<Func<S, TypeCode>>(
// Throws System.ArgumentException in Visual C# 2008 SP1:
            Expression.Call(p, m), p); 
        Func<S, TypeCode> f = e.Compile();
// Throws System.Security.VerificationException in the
// original release version of Visual C# 2008: 
        Console.WriteLine(f(new S())); 
    }
}

10

溢出检查

stackalloc 现在执行溢出检查。

在 Visual C# 2008 的原始发行版中，stackalloc 分配可能在不导致异常的情况下失败。这是因为在将数组长度与每个元素的大小相乘时，没有检查所生成的 Microsoft 中间语言 (MSIL) 中的 mul 指令。在 Visual C# 2008 SP1 中，生成的是 mul.ovf 指令而不是 mul 指令，因此若在运行时尝试分配操作，在发生溢出时将生成 System.OverflowException。

class Program
{
    static void Main(string[] args)
    {
        int var = 0x40000000;
        unsafe
        {
            // 0x40000000 * sizeof(int) does not fit in an int.
            int* listS = stackalloc int[var]; 
// Visual C# 2008 SP1: System.OverflowException.
            listS[0] = 5; 
// Original release version of Visual C# 2008: 
// System.NullReferenceException.
        }
    }
}

13

属性

现在，当一个程序集中两次出现同一 TypeForwardedTo 属性时将发生错误。

在 Visual C# 2005 中，一个程序集包含以同一类型为目标的两个 System.Runtime.CompilerServices.TypeForwardedTo 属性时不产生错误。在 Visual C# 2008 中，这将产生编译器错误 CS0739，如下面的示例所示。

// Class1.cs
// Causes CS0739:
    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(Test))]
    [assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(Test))] 
    public class Test
    {
        public static int Main()
        {
            Test f = new Test();
            return f.getValue();
        }
    }
    // Library1.cs
    public class Test
    {
        public int getValue()
        {
            return 0;
        }

}

15

溢出检查

更正了对 const 十进制类型的范围检查。

在 Visual C# 2005 中，当强制转换 const 十进制类型时，范围检查不总是正确的，可能导致不正确的编译器错误。在 Visual C# 2008 中，下面的代码产生正确的错误：编译器错误 CS0031。

        static void Main()
        {
            const decimal d = -10m;
            unchecked
            {
                const byte b = (byte)d; //CS0031
            }
        }

17

固定大小的缓冲区

现在，如果在为不安全结构中固定大小的缓冲区赋值之前访问该缓冲区，将会产生编译器错误。

不安全指针的明确赋值规则要求在设置指针之后才能取消对指针的引用。在 Visual C# 2005 中，当不安全结构包含指向数组的指针时，在为指针赋值前访问该指针不产生编译器错误。在 Visual C# 2008 中，这将产生编译器错误 CS0165，如下面的代码所示。

    unsafe class Test
    {
        static void Main()
        {
            S* ps;
            ps->i[0]++;        } // CS0165
    }
    unsafe struct S
    {
        public fixed int i[10];
    }

19

迭代器中的 try-finally

现在，当 try 块中的迭代器通过 continue 或 goto 退出时，将执行 finally 块。

在 Visual C# 2005 的 try-finally 构造中，当使用 goto 或 continue 语句将控制权传递到 try 块中的迭代器块以外时，不会执行 finally 块。在 Visual C# 2008 中，这些情况下将执行 finally 块。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace DisposeTest
{
    class A : IDisposable
    {
        int m_n;
        internal A(int n)
        {
            m_n = n;
        }
        internal void Nothing() { }
        ~A()
        {
            Console.WriteLine("failed to dispose {0}", m_n);
        }
        #region IDisposable Members
        public void Dispose()
        {
            GC.SuppressFinalize(this);
            Console.WriteLine("dispose {0}", m_n);
        }
        #endregion
    }
    class Program
    {
        static IEnumerable<A> B()
        {
            for (int nCount = 0; nCount < 2; nCount++)
            {
                Console.WriteLine("loop start");
                using (A A = new A(nCount))
                {
                    Console.WriteLine("using start");
                    // Section 1.
                    // Dispose not called correctly in Visual C# 2005.
                    if ((nCount % 2) == 0)
                        continue;
                    // Section 2.
                    // Dispose not called correctly in Visual C# 2005.
                    yield return A;
                    Console.WriteLine("using end");
                }
                Console.WriteLine("loop end");
            }
            yield break;
        }
        static void Main(string[] args)
        {
            foreach (A A in B())
            {
                A.Nothing();
            }
            Console.ReadLine();
        }
    }

}

21

属性

使用已过时的成员现在生成编译器警告。

可以使用 Obsolete 属性标记方法，调用这些方法会在编译时导致错误或警告。对虚方法设置将此属性时，必须将此属性设置在基方法上。如果在重写方法上设置 Obsolete 属性，则在调用时不会导致编译器错误或警告。在 Visual C# 2005 中，编译器允许在重写方法上设置 Obsolete 属性，但该属性放在那里不起任何作用。在 Visual C# 2008 中，将产生编译器警告编译器警告（等级 1）CS0809“过时成员‘A.Filename’重写未过时成员‘Error.Filename’”。下面的示例导致此警告。

class A : Error
{
    [System.ObsoleteAttribute("Obsolete", true)]
    public override string Filename
    {
        set
        {
        }
    }
    public static void Main() { }
}
public class Error
{
    public virtual string Filename
    {
        set
        {
        }
        get
        {
            return "aa";
        }
    }
}
class B
{
    void TT()
    {
        new A().Filename = "Filename";
    }
}

23

类型错误

现在，当 switch 条件为 void 时，将产生错误。

在 Visual C# 2005 中，当在 switch 语句中使用 void 方法调用时，不会产生错误。在 Visual C# 2008，这将产生编译器错误 CS0151。

class C
{
    static void Main()
    {
// Produces CS0151:
        switch (M()) 
        {
            default:
                break;
        }
    }
    static void M()
    {
    }

}

25

常量表达式

常量表达式更密切符合规范。

在 Visual C# 2008 中，更正了 Visual C# 2005 错误地允许在常量表达式中使用运算符和变量的若干问题。在 Visual C# 2005 中，下面的代码不产生编译错误。在 Visual C# 2008 中，此代码将产生编译器错误 CS0165、编译器警告（等级 1）CS0184 和编译器警告（等级 3）CS1718。

class Program
{
    public static int Main()
    {
        int i1, i2, i3, i4, i5;
        // 'as' is not permitted in a constant expression.
        if (null as object == null)
            i1 = 1;
        // 'is' is not permitted in a constant expression.
        if (!(null is object))
            i2 = 1;
        // A variable is not permitted in a constant expression.
        int j3 = 0;
        if ((0 == j3 * 0) && (0 == 0 * j3))
            i3 = 1;
        int j4 = 0;
        if ((0 == (j4 & 0)) && (0 == (0 & j4)))
            i4 = 1;
        int? j5 = 1;
// Warning CS1718: Comparison made to same variable:
        if (j5 == j5) 
 
            i5 = 1;
        System.Console.WriteLine("{0}{1}{2}{3}{4}{5}", i1, i2, i3, i4, i5);
        return 1;
    }
}

27

可以为 null 的类型和 ?? 表达式

可将常量强制转换为可为 null 的类型，再将该常量赋给可为 null 的类型（更广泛的类型），这样做不会产生警告。

在 Visual C# 2005 中，下面的代码将产生编译器警告（等级 3）CS0219。在 Visual C# 2008 中，此代码不产生警告。

ushort? usq2 = (byte?)0;

29

类型错误

现在，如果声明指向托管类型的指针数组，将产生错误。

不允许使用指向引用类型的不安全指针，这些指针将导致编译器错误。在 Visual C# 2005 中，可以声明指向托管类型的指针数组。在 Visual C# 2008 中，这将产生编译器错误 CS0208：“无法获取托管类型（‘T’）的地址和大小，或无法声明指向它的指针。”

unsafe class TestClass<T>
{
// Produces CS0208:
    static T*[] x = { }; 
// Produces CS0208:
    static void Test(T*[] arr) 
    {
    }
// Produces CS0208:
    static T*[] TestB() 
    {
        return x;
    }

}

31

可以为 null 的类型和 ?? 表达式

左侧为 null 的 null 合并表达式不再计算为 null 常量。

在 Visual C# 2005 中，左侧为 null 的 null 合并表达式计算为 null 常量。在 Visual C# 2008 中不再如此。在某些情况下，Visual C# 2005 的行为使得变量被错误地处理为已明确赋值。下面的代码在 Visual C# 2005 中可以编译并运行而不产生错误，但在 C# 2008 中将产生编译器错误 CS0165：“使用了未赋值的局部变量‘x’”。

static void Main()
    {
        int x;
        if (null == (decimal?)(null ?? null)) x = 1;
        // Producers CS0165 in Visual C# 2008:
        System.Console.WriteLine(x);    
    }