¿Hay alguna diferencia entre el retorno myVar vs. return (myVar)?

Question

Estaba viendo un ejemplo de código C#, y noté que un ejemplo envolvía el retorno en().

Siempre he hecho:

return myRV; 

¿Hay haciendo una diferencia:

return (myRV); 

Answer 1

ACTUALIZACIÓN: Esta pregunta era the subject of my blog on 12 April 2010. Gracias por la divertida pregunta!

En la práctica, no hay diferencia.

En teoría podría haber una diferencia. Hay tres puntos interesantes en la especificación C# donde esto podría presentar una diferencia.

En primer lugar, la conversión de funciones anónimas para delegar tipos y árboles de expresión. Considere lo siguiente:

Func<int> F1() { return()=>1; } 
Func<int> F2() { return (()=>1); } 

F1 es claramente legal. ¿Es F2? Técnicamente, no. The spec dice en la sección 6.5 que hay una conversión de expresión lambda a un tipo de delegado compatible. ¿Es eso una expresión lambda? No. Es una expresión entre paréntesis que contiene una expresión lambda .

El compilador de Visual C# hace una pequeña violación de la especificación aquí y descarta el paréntesis para usted.

Segundo:

int M() { return 1; } 
Func<int> F3() { return M; } 
Func<int> F4() { return (M); } 

F3 es legal. ¿Es F4? No. La sección 7.5.3 establece que una expresión entre paréntesis puede no contener un grupo de métodos. Nuevamente, para su conveniencia, violamos las especificaciones y permitimos la conversión.

Tercero:

enum E { None } 
E F5() { return 0; } 
E F6() { return (0); } 

F5 es legal. ¿Es F6? No. La especificación establece que hay una conversión del cero literal a cualquier tipo enumerado. "(0)" no es el cero literal, es un paréntesis seguido del cero literal, seguido de un paréntesis. Violamos la especificación aquí y de hecho permitimos cualquier expresión de constante de tiempo de compilación igual a cero, y no solo literalmente cero.

Por lo tanto, en todos los casos, le permitimos salirse con la suya, aunque técnicamente hacerlo es ilegal.

Answer 2

No, no hay ninguna diferencia que no sea sintáctica.

Answer 3

Una buena manera de responder preguntas como esta es utilizar Reflector y ver qué IL se genera. Puede aprender mucho acerca de las optimizaciones del compilador y similares mediante la descompilación de ensamblados.

Answer 4

Hay casos extremos cuando la presencia de paréntesis, puede tener efecto sobre el comportamiento del programa:

1.

using System; 

class A 
{ 
    static void Foo(string x, Action<Action> y) { Console.WriteLine(1); } 
    static void Foo(object x, Func<Func<int>, int> y) { Console.WriteLine(2); } 

    static void Main() 
    { 
     Foo(null, x => x()); // Prints 1 
     Foo(null, x => (x())); // Prints 2 
    } 
} 

2.

using System; 

class A 
{ 
    public A Select(Func<A, A> f) 
    { 
     Console.WriteLine(1); 
     return new A(); 
    } 

    public A Where(Func<A, bool> f) 
    { 
     return new A(); 
    } 

    static void Main() 
    { 
     object x; 
     x = from y in new A() where true select (y); // Prints 1 
     x = from y in new A() where true select y; // Prints nothing 
    } 
} 

3.

using System; 

class Program 
{ 
    static void Main() 
    { 
     Bar(x => (x).Foo(), ""); // Prints 1 
     Bar(x => ((x).Foo)(), ""); // Prints 2 
    } 

    static void Bar(Action<C<int>> x, string y) { Console.WriteLine(1); } 
    static void Bar(Action<C<Action>> x, object y) { Console.WriteLine(2); } 
} 

static class B 
{ 
    public static void Foo(this object x) { } 
} 

class C<T> 
{ 
    public T Foo; 
} 

Espero que nunca neve Ver esto en la práctica.