Gibt es einen Unterschied zwischen return myVar und return (myVar)?

Ich habe mir einen Beispiel-C # -Code angesehen und festgestellt, dass ein Beispiel die Rückgabe in () eingeschlossen hat.

Ich habe es immer gerade getan:

return myRV;

Gibt es einen Unterschied:

return (myRV);

UPDATE: Diese Frage war das Thema meines Blogs am 12. April 2010 . Danke für die amüsante Frage!

In der Praxis gibt es keinen Unterschied.

In der Theorie könnte es ein Unterschied. Es gibt drei interessante Punkte in der C # -Spezifikation, an denen dies einen Unterschied darstellen könnte.

Erstens die Konvertierung anonymer Funktionen zum Delegieren von Typen und Ausdrucksbäumen. Folgendes berücksichtigen:

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

F1ist eindeutig legal. Ist F2? Technisch gesehen nein. Die Spezifikation in Abschnitt 6.5 besagt, dass eine Konvertierung von einem Lambda-Ausdruck in einen kompatiblen Delegatentyp erfolgt. Ist das ein Lambda-Ausdruck ? Nein. Es ist ein Ausdruck in Klammern , der einen Lambda-Ausdruck enthält .

Der Visual C # -Compiler macht hier eine kleine Spezifikationsverletzung und verwirft die Klammern für Sie.

Zweite:

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

F3ist legal. Ist F4? Nein. Abschnitt 7.5.3 besagt, dass ein Ausdruck in Klammern möglicherweise keine Methodengruppe enthält. Auch hier verstoßen wir zur Vereinfachung gegen die Spezifikation und erlauben die Konvertierung.

Dritte:

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

F5ist legal. Ist F6? Nein. Die Spezifikation besagt, dass eine Konvertierung von der wörtlichen Null in einen beliebigen Aufzählungstyp erfolgt. " (0)" ist nicht die wörtliche Null, sondern eine Klammer, gefolgt von der wörtlichen Null, gefolgt von einer Klammer. Wir verletzen hier die Spezifikation und erlauben tatsächlich jeden Ausdruck einer Kompilierungszeitkonstante gleich Null und nicht nur eine wörtliche Null.

In jedem Fall erlauben wir Ihnen, damit durchzukommen, auch wenn dies technisch illegal ist.

Es gibt Eckfälle, in denen das Vorhandensein von Klammern das Programmverhalten beeinflussen kann:

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;
}

Ich hoffe, Sie werden dies in der Praxis nie sehen.

Nein, es gibt keinen anderen Unterschied als syntaktisch.

Eine gute Möglichkeit, Fragen wie diese zu beantworten, besteht darin, Reflector zu verwenden und zu sehen, welche IL generiert wird. Sie können viel über Compiler-Optimierungen und dergleichen lernen, indem Sie Assemblys dekompilieren.