Compartir a través de

Cambios importantes de Visual C# en Visual Studio 2012

  • Artículo

La tabla siguiente se indican los cambios en Visual c# en Visual Studio 2012 que podría cualquiera evitar una aplicación creada en Visual c# en Visual Studio 2010 de la compilación o cambiar el comportamiento en tiempo de ejecución de una aplicación.

Categoría

Problema

Descripción

Expresiones lambda

Puede utilizar la variable de iteración de una instrucción de foreach en una expresión lambda que está incluido en el cuerpo del bucle.

El uso de una variable de iteración de foreach en una expresión lambda anidada no presenta más resultados inesperados.El ejemplo siguiente utiliza word variable en una expresión 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

Expresiones LINQ

Puede utilizar la variable de iteración de una instrucción de foreach en una expresión LINQ incluido en el cuerpo del bucle.

El uso de una variable de iteración de foreach en una expresión LINQ no presenta más resultados inesperados.El ejemplo siguiente utiliza number variable en una 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 con nombre

Los efectos secundarios de argumentos con nombre y tabulares en una llamada al método aparecen ahora de izquierda a derecha en la lista de argumentos.

Los efectos secundarios de los argumentos con nombre y tabular que se combinan en una llamada al método ahora se generan de izquierda a derecha en la lista de argumentos de la instrucción de llamada.En el ejemplo siguiente, TestMethod se realiza mediante una combinación de argumentos con nombre y tabulares en diferentes pedidos.

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
}

Resolución de sobrecarga

La resolución de sobrecarga se ha mejorado para llamadas que utilizan argumentos con nombre a los métodos de acceso que contienen los parámetros de params.

Cuando se encuentra más de un candidato de resolución, la resolución de sobrecarga prefiere la mayoría de tipo concreto para los argumentos con nombre.Se consideran los parámetros para los que los argumentos no son necesarios ni se proporcionan en la llamada cuando coincide con el tipo de candidatos de sobrecarga son igualmente buenas.

En el ejemplo siguiente, string es mejor tipo que object para p2.Por consiguiente, la versión de ExampleMethod en la que se define el parámetro p2 como una cadena debe ser elegida, aunque tiene un parámetro de params de otros fabricantes.

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

Resolución de sobrecarga

La resolución de sobrecarga se mejora para las llamadas donde el algoritmo debe elegir entre un parámetro de Func<object> y un parámetro de Func que tiene otro parámetro de tipo (por ej., string o int?) para un argumento de Func<dynamic>.

En el ejemplo siguiente, la llamada a CandidateMethod que envía un argumento de Func<dynamic> tiene dos candidatos de resolución.El parámetro correspondiente en uno de los candidatos es Func<object>, y el parámetro correspondiente en el otro es Func<string>.

El candidato de sobrecarga que tiene un parámetro de Func<object> debe ser elegido porque object y dynamic se consideran equivalentes.Por consiguiente, la conversión de identidad existe no sólo entre dynamic y object sino también entre los tipos construidos Func<dynamic> y 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.

Vea también

Referencia

Expresiones lambda (Guía de programación de C#)

params (Referencia de C#)

dynamic (Referencia de C#)

Conceptos

Argumentos opcionales y con nombre (Guía de programación de C#)

Otros recursos

Introducción a Visual C#

¿Cuándo una corrección el no interrumpir de lenguaje está colocando?