return myVar와 return (myVar) 사이에 차이점이 있습니까?

몇 가지 예제 C # 코드를 살펴본 결과 한 예제가 ()에 반환을 래핑하는 것을 알았습니다.

나는 항상 그랬다.

return myRV;

차이가 있습니까?

return (myRV);

업데이트 :이 질문은 2010 년 4 월 12 일 제 블로그의 주제였습니다 . 재미있는 질문에 감사드립니다!

실제로는 차이가 없습니다.

에 이론 차이가있을 수 있습니다. C # 사양에는 이것이 차이를 나타낼 수있는 세 가지 흥미로운 점이 있습니다.

첫째, 익명 함수를 대리자 형식 및 식 트리로 변환합니다. 다음을 고려하세요:

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

F1분명히 합법적입니다. 인가 F2? 기술적으로는 아닙니다. 사양 은 섹션 6.5에서 람다 식에서 호환되는 대리자 형식으로 의 변환이 있다고 말합니다 . 그는인가 람다 식 ? 아니요 . 람다 식 을 포함하는 괄호로 묶인 식 입니다 .

Visual C # 컴파일러는 여기서 작은 사양 위반을 만들고 괄호를 삭제합니다.

둘째:

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

F3합법적입니다. 인가 F4? 아니요. 섹션 7.5.3에는 괄호로 묶인 식에 메서드 그룹이 포함될 수 없다고 명시되어 있습니다. 다시 말하지만, 귀하의 편의를 위해 사양을 위반하고 변환을 허용합니다.

제삼:

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

F5합법적입니다. 인가 F6? 아니요. 사양에는 리터럴 0에서 열거 된 유형으로의 변환이 있다고 명시되어 있습니다. " (0)"은 리터럴 0이 아니며 괄호 뒤에 리터럴 0, 괄호가 이어집니다. 여기서 사양을 위반하고 실제로 리터럴 0뿐만 아니라 0과 같은 컴파일 시간 상수 표현식을 허용합니다 .

따라서 모든 경우에 우리는 기술적으로 불법이더라도 당신이 그것을 피할 수 있도록 허용합니다.

괄호가 프로그램 동작에 영향을 미칠 수있는 경우가 있습니다.

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

삼.

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

실제로는 이것을 결코 볼 수 없기를 바랍니다.

아니요, 구문론 외에는 차이가 없습니다.

이와 같은 질문에 답하는 좋은 방법은 Reflector를 사용하여 IL이 생성되는 것을 확인하는 것입니다. 어셈블리를 디 컴파일하여 컴파일러 최적화 등에 대해 많은 것을 배울 수 있습니다.