Sdílet prostřednictvím

Zásadní změny v jazyce Visual C# v sadě Visual Studio 2012

  • Článek

V následující tabulce jsou uvedeny změny v jazyce Visual C# v Visual Studio 2012 , by mohly bránit aplikaci, která byla vytvořena v jazyce Visual C# v aplikaci Visual Studio 2010 z kompilace nebo změnit chování běhu takové aplikace.

Kategorie

Problém

Description

Lambda výrazy

Iterační proměnné lze použít foreach prohlášení v lambda výrazu, který je součástí těla smyčky.

Použití foreach iterační proměnná v vnořené lambda výraz již poskytuje neočekávané výsledky.Následující příklad používá proměnné word v lambda výrazu.

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

Výrazy LINQ

Iterační proměnné lze použít foreach prohlášení v LINQ výraz, který je součástí těla smyčky.

Použití foreach iterační proměnná v LINQ výraz již poskytuje neočekávané výsledky.Následující příklad používá proměnné number v dotazu 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

Pojmenované argumenty

Vedlejší účinky z pozičních a pojmenovaných argumenty při volání metody nyní dojít zleva doprava, v seznamu argumentů.

Vedlejší účinky z pozičních a pojmenovaných argumentů, které jsou kombinovány ve volání metody jsou nyní vyrábí zleva doprava v seznamu argumentů volání příkazu.V následujícím příkladu TestMethod je volána pomocí kombinaci pozičních a pojmenovaných argumentů v různém pořadí.

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
}

Rozlišení přetěžování

Přetížení rozlišení bylo vylepšeno pro volání, které používají pojmenované argumenty přístup k metodám, které obsahují params parametry.

Po nalezení více kandidátských řešení s pozdní vazbou upřednostňuje nejvíce odpovídá typu pro pojmenované argumenty.Parametry, u kterých nejsou argumenty požadované nebo ve výzvě k dispozici, jsou považovány za pouze pokud typ shody v přetížení kandidátů, stejně dobré.

V následujícím příkladu string je lepší než typ object pro p2.Proto verze ExampleMethod ve kterém parametr p2 je definován jako řetězce by měly být zvoleny, přestože má třetí params parametr.

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

Rozlišení přetěžování

Lepší rozlišení přetížení pro volání, kde musíte zvolit algoritmus Func<object> parametr a Func parametr, který má jiný typ parametru (např. v string nebo int?) pro Func<dynamic> argument.

V následujícím příkladu volání CandidateMethod , odešle Func<dynamic> argument má dva kandidáty rozlišení.Odpovídající parametr v jednom z kandidátů je Func<object>, a odpovídající parametr v druhé je Func<string>.

Přetížení kandidát, který má Func<object> parametr by měla být zvolena, protože object a dynamic jsou považovány za rovnocenné.Proto existuje převodu identity není pouze mezi dynamic a object , ale také mezi konstruované typy Func<dynamic> a 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.

Viz také

Referenční dokumentace

Lambda výrazy (Příručka programování C#)

Parametry (C#-Reference)

dynamické (C#-Reference)

Koncepty

Pojmenované a volitelné argumenty (Příručka programování C#)

Další zdroje

Začínáme s Visual C#

Pokud je oprava jazyk pevné rozdělení?