Partager via

Changements majeurs au niveau de Visual C# dans Visual Studio 2012

  • Article

Le tableau suivant répertorie les modifications dans Visual C# dans Visual Studio 2012 qui peut soit empêcher une application créée dans Visual C# dans Visual Studio 2010 de la compilation ou modifier le comportement à l'exécution de cette application.

Catégorie

Problème

Description

expressions lambda

Vous pouvez utiliser la variable d'itération d'une instruction d'une boucle foreach dans une expression lambda qui est contenue dans le corps de la boucle.

L'utilisation d'une variable d'itération de boucle foreach dans une expression lambda imbriquée ne produit plus des résultats inattendus.L'exemple suivant utilise la variable word dans une expression 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

LINQ Expressions

Vous pouvez utiliser la variable d'itération d'une instruction d'une boucle foreach dans une expression LINQ qui est contenue dans le corps de la boucle.

L'utilisation d'une variable d'itération foreach dans une expression LINQ ne produit plus des résultats inattendus.L'exemple suivant illustre number dans une requête 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

Arguments nommés

Les effets secondaires de nommé et les arguments de position dans un appel de méthode se produisent maintenant de gauche à droite dans la liste d'arguments.

Les effets secondaires de nommé et les arguments de position qui sont regroupés dans un appel de méthode sont maintenant produits de gauche à droite dans la liste d'arguments d'appel de l'instruction.Dans l'exemple suivant, TestMethod est appelé à l'aide d'une combinaison d'arguments nommés et de position dans des ordres différents.

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
}

Résolution de surcharge

La résolution de surcharge a été améliorée pour les appels qui utilisent arguments nommés aux méthodes d'accès qui contiennent des paramètres de params .

Lorsque plus d'un candidat de résolution est trouvé, la résolution de surcharge préfère le type le plus spécifique correspondant aux arguments nommés.Les paramètres pour lesquels les arguments ne sont pas requis ou ne sont pas spécifiés dans l'appel sont considérés uniquement lorsque le type correspond dans les candidats de surcharge sont également bon.

Dans l'exemple suivant, string est un meilleur type que object pour p2.Par conséquent, la version de ExampleMethod dans laquelle le paramètre p2 est défini comme une chaîne doit être sélectionné, bien qu'elle ait un paramètre de type params tiers.

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

Résolution de surcharge

La résolution de surcharge est améliorée pour les appels où l'algorithme doit choisir entre un paramètre d' Func<object> et un paramètre d' Func qui a un paramètre de type différent (par exemple, string ou int?) pour un argument d' Func<dynamic> .

Dans l'exemple suivant, l'appel à CandidateMethod qui envoie un argument de type Func<dynamic> a deux candidats de résolution.Le paramètre correspondant dans l'un des candidats est Func<object>, et le paramètre correspondant dans l'autre est Func<string>.

Le candidat de surcharge qui a un paramètre de type Func<object> doit être choisi parce que les types object et dynamic sont considérés comme équivalents.Par conséquent, une conversion d'identité n'existe pas uniquement entre dynamic et object mais également entre les types construits Func<dynamic> et 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.

Voir aussi

Référence

Expressions lambda (Guide de programmation C#)

params (référence C#)

dynamic (Référence C#)

Concepts

Arguments nommés et facultatifs (Guide de programmation C#)

Autres ressources

Mise en route de Visual C#

Lorsque puis qu'un correctif insécable de langage arrête ?