Alterações significativas do Visual C# no Visual Studio 2012

  • Artigo

A tabela a seguir lista alterações no Visual c# em Visual Studio 2012 qualquer um que pode evitar um aplicativo que foi criado em Visual c# no Visual Studio 2010 de compilação ou alterar o comportamento de tempo de execução de um aplicativo.

Categoria

Problema

Descrição

Expressões Lambda

Você pode usar a variável de iteração de uma instrução de foreach em uma expressão lambda que está contida no corpo do loop.

O uso de uma variável de iteração de foreach em uma expressão lambda aninhada não produz resultados inesperados.O exemplo a seguir usa word variável em uma expressão 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

Expressões LINQ

Você pode usar a variável de iteração de uma instrução de foreach em uma expressão LINQ que está contida no corpo do loop.

O uso de uma variável de iteração de foreach em uma expressão LINQ não produz resultados inesperados.O exemplo a seguir usa number variável em uma consulta 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

Argumentos nomeados

Os efeitos colaterais dos argumentos nomeados e posicionais em um chamada de método ocorrem agora da esquerda para a direita na lista de argumentos.

Os efeitos colaterais dos argumentos nomeados e posicionais que são combinados em uma chamada de método são gerados agora da esquerda para a direita na lista de argumentos de instrução de chamada.No exemplo a seguir, TestMethod é chamado usando uma combinação de argumentos nomeados e posicionais pedidos em diferentes.

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
}

Resolução de sobrecarga

Resolução de sobrecarga foi aprimorada para chamadas que usam argumentos nomeados para acessar os métodos que contêm parâmetros de params .

Quando mais de um candidato de resolução é encontrado, a resolução de sobrecarga preferir a maioria de correspondência de tipo específico para argumentos nomeados.Os parâmetros para os argumentos não são necessários ou não são fornecidos na chamada são considerados somente quando as correspondências de tipo em candidatas a sobrecarga são igualmente boas.

No exemplo a seguir, string é um tipo melhor do que object para p2.Portanto, a versão de ExampleMethod em que o parâmetro p2 é definido como uma cadeia de caracteres deve ser escolhida, mesmo que tem um parâmetro de params do terceiro.

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

Resolução de sobrecarga

Resolução de sobrecarregamento é aprimorada para chamadas onde o algoritmo deve escolher entre um parâmetro de Func<object> e um parâmetro de Func que tem um parâmetro de tipo diferente (por exemplo, string ou int?) para um argumento de Func<dynamic> .

No exemplo a seguir, a chamada a CandidateMethod que envia um argumento de Func<dynamic> tem dois candidatos de resolução.O parâmetro correspondente em um dos candidatos é Func<object>, e o parâmetro correspondente no outro é Func<string>.

O candidato do sobrecarregamento que tem um parâmetro de Func<object> deve ser escolhido como object e dynamic são considerados equivalentes.Portanto, uma conversão de identidade não existe somente entre dynamic e object mas também entre tipos construídos 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.

Consulte também

Referência

Expressões lambda (guia de programação do C#)

params (referência de C#)

dinâmico (referência de C#)

Conceitos

Argumentos nomeados e opcionais (guia de programação do C#)

Outros recursos

Getting Started with Visual C#

Quando uma correção não quebrar do idioma são quebrando?