Condividi tramite

Ultime modifiche di Visual C# in Visual Studio 2012

  • Articolo

Nella tabella seguente sono elencate le modifiche in Visual c in Visual Studio 2012 che potrebbe o impedire un'applicazione creata in Visual c in Visual Studio 2010 dalla compilazione o modificare il comportamento di tale applicazione.

Category

Problema

Descrizione

Espressioni lambda

È possibile utilizzare la variabile di iterazione di un'istruzione di foreach in un'espressione lambda contenuta nel corpo del ciclo.

L'utilizzo di una variabile di iterazione di foreach in un'espressione lambda annidata più non forniscono risultati imprevisti.Nell'esempio riportato word variabile in un'espressione lambda.

static void Main()
{
    var methods = new List<Action>();
    foreach (var word in new string[] { "hello", "world" })
    {
        methods.Add(() => Console.Write(word + " "));
    }

    methods[0]();
    methods[1]();
}

// Output in Visual Studio 2012: 
// hello world

// Output in Visual Studio 2010: 
// world world

Espressioni LINQ

È possibile utilizzare la variabile di iterazione di un'istruzione di foreach in un'espressione LINQ contenuta nel corpo del ciclo.

L'utilizzo di una variabile di iterazione di foreach in un'espressione LINQ non fornisce più risultati imprevisti.Nell'esempio riportato number variabile in una query LINQ.

static void Main()
{
    var lines = new List<IEnumerable<string>>(); 
    int[] numbers = { 1, 2, 3 };
    char[] letters = { 'a', 'b', 'c' };

    foreach (var number in numbers)
    {
        var line = from letter in letters
                   select number.ToString() + letter;

        lines.Add(line);
    }

    foreach (var line in lines)
    {
        foreach (var entry in line)
            Console.Write(entry + " ");
        Console.WriteLine();
    }
}
// Output in Visual Studio 2012: 
// 1a 1b 1c
// 2a 2b 2c
// 3a 3b 3c

// Output in Visual Studio 2010: 
// 3a 3b 3c
// 3a 3b 3c
// 3a 3b 3c

Argomenti predefiniti

Gli effetti collaterali gli argomenti denominati e posizionali in una chiamata al metodo ora si verificano da sinistra a destra nell'elenco di argomenti.

Gli effetti collaterali gli argomenti denominati e posizionali che vengono combinati in una chiamata al metodo sono ora prodotti da sinistra a destra nell'elenco di argomenti di chiamata dell'istruzione.Nell'esempio seguente, TestMethod viene chiamato utilizzando una combinazione di argomenti denominati e posizionali gli ordini diversi.

class Program
{
    static void Main(string[] args)
    {
        TestMethod(WriteLetter("A"), b: WriteLetter("B"), c: WriteLetter("C"));
        TestMethod(WriteLetter("A"), c: WriteLetter("C"), b: WriteLetter("B"));
    }

    static int WriteLetter(string letter)
    {
        Console.Write(letter + " ");
        return 1;
    }

    static void TestMethod(int a, int b, int c)
    { }

    // Output in Visual Studio 2012:
    // A B C A C B

    // Output in Visual Studio 2010:
    // B C A C B A
}

Risoluzione di l

La risoluzione dell'overload è stata migliorata per le chiamate che utilizzano argomenti predefiniti ai metodi di accesso che contengono i parametri di params.

Quando più di un candidato di risoluzione viene trovato, la risoluzione di l preferisce la corrispondenza del tipo specifico di argomenti predefiniti.Gli argomenti di parametri per il quale non sono necessari o fornita nella chiamata sono considerati solo quando le corrispondenze di tipo nei candidati dell'overload presentano lo stesso livello di efficienza.

Nell'esempio seguente, string è un tipo migliore che object per p2.Pertanto, la versione di ExampleMethod in cui il parametro p2 viene definito come una stringa deve essere scelta, anche se presenta un parametro di params di terzo.

class Program
{
    static void Main(string[] args)
    {
        ExampleMethod(p2: "");
    }

    public static void ExampleMethod(string p1 = null, object p2 = null)
    {
        Console.WriteLine("ExampleMethod: p2 is object");
    }
    public static void ExampleMethod(string p2 = null, object p1 = null, params int[] p3)
    {
        Console.WriteLine("ExampleMethod: p2 is string");
    }
}

// Output in Visual Studio 2012:
// ExampleMethod: p2 is string

// Output in Visual Studio 2010:
// ExampleMethod: p2 is object

Risoluzione di l

La risoluzione dell'overload è migliorata per le chiamate in cui l'algoritmo deve stabilire tra un parametro di Func<object> e un parametro di Func con un parametro di tipo diverso, ad esempio string o int?) per un argomento di Func<dynamic>.

Nell'esempio seguente, la chiamata a CandidateMethod che invia un argomento di Func<dynamic> ha due candidati di risoluzione.Il parametro corrispondente in uno dei candidati è Func<object>e il parametro corrispondente nell'altro è Func<string>.

Il candidato di overload che dispone di un parametro di Func<object> deve essere sceltoe perché object e dynamic vengono considerati equivalenti.Di conseguenza, una conversione di identità non esiste solo tra dynamic e object ma anche tra i tipi costruiti Func<dynamic> e Func<object>.

class Program
{
    public static void CandidateMethod(Func<object> fun)
    {
        Console.WriteLine("Method that has a Func<object> parameter.");
    }

    public static void CandidateMethod(Func<string> fun)
    {
        Console.WriteLine("Method that has a Func<string> parameter.");
    }

    static void Main(string[] args)
    {
        dynamic dyn = 15;
        CandidateMethod(() => { return dyn; });
    }
}
// Output in Visual Studio 2012:
// Method that has a Func<object> parameter.

// Output in Visual Studio 2010 if Microsoft.CSharp is referenced:
// Method that has a Func<string> parameter.

// Output in Visual Studio 2010 if Microsoft.CSharp isn't referenced (for instance, in a Unit Test Project):
// Method that has a Func<object> parameter.

Vedere anche

Riferimenti

Espressioni lambda (Guida per programmatori C#)

params (Riferimenti per C#)

dynamic (Riferimenti per C#)

Concetti

Argomenti denominati e facoltativi (Guida per programmatori C#)

Altre risorse

Guida introduttiva a Visual C#

Quando una non l'interruzione di linguaggio di interrompendosi?