Wichtige Änderungen in Visual C# 2010

Kovarianz und Kontravarianz

Für generische Schnittstellen und Delegaten, z. B. IEnumerable<T> und Func<TResult>, wurde eine neue implizite Konvertierung hinzugefügt.

Generische Schnittstellen und Delegaten, z. B. IEnumerable<T> und Func<TResult>, verfügen jetzt über eine implizite Konvertierung für generische Typargumente. Beispielsweise kann in C# 2010 IEnumerable<string> implizit in IEnumerable<object> konvertiert werden, und dies kann in den folgenden Szenarien unterschiedliches Verhalten verursachen.

• Überprüfen der Typkompatibilität mithilfe des is-Schlüsselworts.

  IEnumerable<string> strings = 
      new List<string>();
  if (strings is IEnumerable<object>)
      Console.WriteLine("True");
  else
      Console.WriteLine("False");
  // Prints different results.
  // C# 2008: False
  // C# 2010: True

• Überladungsauflösung. In C# 2010 wird eine Methode gewählt, die über ein generisches Argument verfügt, das Varianzregeln erfüllt, während in C# 2008 immer ein nicht generisches Argument gewählt wird.

  class Program
  {
      public static void Test(IEnumerable e)
      {
          Console.WriteLine("IEnumerable");
      }
      public static void Test(IEnumerable<object> e)
      {
          Console.WriteLine("IEnumerable<object>");
      }
      static void Main(string[] args)
      {
          Test(new List<string>());
          // Prints different results.
          // C# 2008: IEnumerable
          // C# 2010: IEnumerable<object>
      }
  }

Weitere Informationen finden Sie unter Kovarianz und Kontravarianz (C# und Visual Basic).

Typrückschluss für Methodengruppen

Der Compiler kann für Methodengruppen generische und nicht generische Delegaten ableiten, und dies kann zu Mehrdeutigkeit führen.

In C# 2008 kann der Compiler keine generischen Delegaten für Methodengruppen ableiten. Deshalb verwendet er immer einen nicht generischen Delegaten, sofern vorhanden.

In C# 2010 werden für Methodengruppen sowohl generische als auch nicht generische Delegaten abgeleitet, und der Compiler leitet mit gleicher Wahrscheinlichkeit generische oder nicht generische Delegaten ab. Dies kann zu Mehrdeutigkeit führen, wenn eine generische und eine nicht generische Version eines Delegaten vorhanden sind und beide Versionen die Anforderungen erfüllen. Beispielsweise wird in C# 2008 der folgende Code kompiliert, und der Code ruft eine Methode auf, die einen nicht generischen Delegaten verwendet. In C# 2010 erzeugt dieser Code einen Compilerfehler aufgrund eines mehrdeutigen Aufrufs.

public class Sample
{
    delegate string NonGenericDelegate();
    delegate T GenericDelegate<T>();
    string UseDelegate(NonGenericDelegate del)
    {
        return null;
    }

    T UseDelegate<T>(GenericDelegate<T> del)
    {
       return default(T);
    }

    public string Test()
    {
       // This line produces 
       // a compiler error in C# 2010.
       return UseDelegate(Test);
    }
}

Eingebettete Interoptypen

Der Versuch, mit CoClass eine Instanz eines eingebetteten COM-Typs zu erstellen, führt zu einem Compilerfehler.

Wenn Sie in C# 2010 einen Verweis auf eine Interopassembly, z. B. Microsoft.Office.Interop.Word oder Microsoft.Office.Interop.Excel, hinzufügen, werden die Typen aus dieser Assembly eingebettet. Weitere Informationen finden Sie unter Exemplarische Vorgehensweise: Einbetten von Typen aus verwalteten Assemblys (C# und Visual Basic) und /link (C#-Compileroptionen).

Wenn Sie im Code eine Instanz eines eingebetteten COM-Typs erstellen, müssen Sie die Instanz mit der entsprechenden Schnittstelle erstellen. Wenn Sie versuchen, mit der CoClass eine Instanz eines eingebetteten COM-Typs erstellen, meldet der Compiler einen Fehler.

// Add the following statement
// at the beginning of the file:
// using Word = Microsoft.Office.Interop.Word;
// This statement does not compile in C# 2010.
Word.Application wordClass = 
    new Word.ApplicationClass();
// Use the following code instead.
Word.Application wordInterface = 
    new Word.Application();

Ereignissynchronisierung

Die Synchronisierung zum Schreiben in das dahinter liegende Feld eines Ereignisses in den vom Compiler generierten Methoden zum Hinzufügen und Entfernen erfolgt jetzt mit der CompareExchange-Methode. Dies kann eine Racebedingung verursachen.

In C# 2010 erfolgt die Synchronisierung zum Ändern des dahinter liegenden Felds für die vom Compiler generierten Methoden zum Hinzufügen und Entfernen mit der CompareExchange-Methode statt mit MethodImplAttribute.

Dies kann Racebedingungen verursachen, die in C# 2008 nicht aufgetreten sind, wie im folgenden Codebeispiel gezeigt.

using System;
using System.Threading;

class Sample
{
    public event Action sampleEvent;

    static void Main()
    {
        new Sample().Loop();
    }

    void Loop()
    {
        new Thread(() => Test.Method(this)).Start();
        while (true)
        {
            lock (this)
            {
                if (sampleEvent != null)
                {
                    // In C# 2010, sampleEvent 
                    // can be null here,
                    // which causes 
                    // a run-time exception.
                    sampleEvent();
                }
            }
        }
    }
}

class Test
{
    public static void Method(Sample arg)
    {
        while (true)
        {
            arg.sampleEvent += Method;
            arg.sampleEvent -= Method;
        }
    }
    static void Method() { }
}

Um die Racebedingung zu vermeiden, ändern Sie die Loop-Methode wie im folgenden Codebeispiel gezeigt.

void Loop()
{
   new Thread(() => Test.Method(this)).Start();
   while (true)
   {
       lock (this)
       {
           // Create a local copy of the delegate.
           Action local = sampleEvent;
           if (local != null)
           {
               local();
           }
        }
    }
}