为什么在C#和VB.NET之间获取成员表达式成员名称有所不同？

Question

我有以下C#方法:

private static string GetMemberName<T>(Expression<Func<T>> expr)
{
    MemberExpression memberExpr = expr.Body as MemberExpression;

    if (memberExpr == null) 
        throw new ArgumentOutOfRangeException("Wrong type of lambda...");

    return memberExpr.Member.Name;
}

我可以像这样使用它来打印类级别字段,方法参数或本地var的名称(注意这是pre-C#6.0 nameof运算符):

private static int _myFieldVar  = 62;

private static void DoStuff(int myMethodParam)
{
    int myLocalVar = 2;
    Debug.Print(GetMemberName(() => myMethodParam)); // prints "myMethodParam"
    Debug.Print(GetMemberName(() => myLocalVar)); // prints "myLocalVar"
    Debug.Print(GetMemberName(() => _myFieldVar)); // _myFieldVariable
}

现在我想将此代码转换为VB.NET,所以这里是GetMemberName方法:

Private Function GetMemberName(Of T)(expr As Expression(Of Func(Of T))) As String
    Dim memberExpr As MemberExpression = TryCast(expr.Body, MemberExpression)

    If memberExpr Is Nothing Then _
        Throw New ArgumentOutOfRangeException("Wrong type of lambda...")

    Return memberExpr.Member.Name
End Function

但是,当我得到方法参数和局部变量名称时,我注意到不同的结果,即它们都以" $ VB $ Local_ " 为前缀:

Private _myFieldVar As Integer = 62

Private Sub DoThis(myMethodParam As Integer)
    Dim myLocalVar = 2
    Debug.Print(GetMemberName(Function() myMethodParam)) ' prints "$VB$Local_myMethodParam""
    Debug.Print(GetMemberName(Function() myLocalVar)) ' prints "$VB$Local_myLocalVar"
    Debug.Print(GetMemberName(Function() _myFieldVar)) ' prints "_myFieldVar()" 
End Sub

我用Google搜索"$ VB $ Local_",发现这个帖子非常相似.但是,我认为我的问题不同,因为我没有使用属性获得此行为.如果我这样称呼:

Debug.Print(GetMemberName(Function() MyProperty))

我得到"MyProperty".此外,我的基本问题是"为什么C#和VB.NET之间的行为不同,即"$ VB $ Local_"的含义是什么？为什么它在C#中不存在",而那篇帖子更关心如何避免VB.NET中的那种行为.

Answer 1

正如 Hans Passant 所提到的，两个编译器使用略有不同的命名策略来处理 Linq 表达式树中的局部变量。让我们看一下两个输出的反编译结果。我使用 ILSpy 时，在“视图”=>“选项”=>“反编译器”选项卡中未选中所有选项。我还稍微简化了输出表达式树，以保持答案简洁。

C＃

    public static string Test()
    {
        int myLocalVar = 2;
        int myLocalVar2 = 2; // local varible never exported! note how it is not in the generated class
        myLocalVar2++;
        return GetMemberName(() => myLocalVar);
    }

输出

    [CompilerGenerated]
    private sealed class <>c__DisplayClass1_0
    {
        public int myLocalVar;
    }

    public static string Test()
    {
        Class1.<>c__DisplayClass1_0 <>c__DisplayClass1_ = new Class1.<>c__DisplayClass1_0();
        <>c__DisplayClass1_.myLocalVar = 2;
        int num = 2;
        num++;
        return Class1.GetMemberName<int>(
            Expression.Lambda<Func<int>>(
                Expression.MakeMemberAccess(
                    Expression.Constant(<>c__DisplayClass1_, typeof(Class1.<>c__DisplayClass1_0)),
                    typeof(Class1.<>c__DisplayClass1_0).GetMember("myLocalVar")
                )
            )
        );
    }

VB

Public Shared Function Test() As String
    Dim myLocalVar As Integer = 2
    Dim myLocalVar2 As Integer = 2
    myLocalVar2 = myLocalVar2 + 1
    Return GetMemberName(Function() myLocalVar)
End Function

输出

    [CompilerGenerated]
    internal sealed class _Closure$__2-0
    {
        public int $VB$Local_myLocalVar;
    }

    public static string Test()
    {
        Class1._Closure$__2-0 closure$__2- = new Class1._Closure$__2-0();
        closure$__2-.$VB$Local_myLocalVar = 2;
        int num = 2;
        num++;
        return Class1.GetMemberName<int>(
            Expression.Lambda<Func<int>>(
                Expression.MakeMemberAccess(
                    Expression.Constant(closure$__2-, typeof(Class1._Closure$__2-0)), 
                    typeof(Class1._Closure$__2-0).GetMember("$VB$Local_myLocalVar")
                )
            )
        );
    }

两个编译器都会创建一个private sealed classfor myLocalVar。这样做是为了满足 Linq 表达式树的要求。表达式树需要捕获对局部变量的引用。下面的示例说明了为什么需要这样做。

       int localVar = 1;
       Expression<Func<int>> express = () => localVar;
       var compiledExpression = express.Compile();
       Console.WriteLine(compiledExpression());//1
       localVar++;
       Console.WriteLine(compiledExpression());//2
       Console.ReadLine();

回到问题 - 为什么 C# 和 VB.NET 之间的行为不同，即“$VB$Local_”的含义是什么以及为什么它在 C# 中不存在？

编译器为我们生成了令人难以置信的大量代码，C# 和 VB.NET 的处理方式略有不同。所以我只想回答为什么VB插入$VB$Local_. ** 为了避免名称冲突。** C# 的 DisplayClass 和 VB.Net 的 Closure 都有多种用途。为了避免发生冲突，名称以代表源的键为前缀。事实证明，C# 的关键是什么都没有，所有其他语言功能都对 DisplayClass 前缀有其他贡献。尝试反编译以下VB.net，看看为什么需要前缀键。

Sub Main()
    Dim myLocalVar As Integer = 2
    Dim x1 As System.Action(Of Integer) = Sub(x)
                                              System.Console.WriteLine(x)
                                              GetMemberName(Function() myLocalVar)

                                          End Sub
    x1(2)
End Sub

编译后的闭包如下。

    [CompilerGenerated]
    internal sealed class _Closure$__2-0
    {
        public int $VB$Local_myLocalVar;

        internal void _Lambda$__0(int x)
        {
            Console.WriteLine(x);
            Class1.GetMemberName<int>(Expression.Lambda<Func<int>>(Expression.Field(Expression.Constant(this, typeof(Class1._Closure$__2-0)), fieldof(Class1._Closure$__2-0.$VB$Local_myLocalVar)), new ParameterExpression[0]));
        }

async 和await 也以这种方式使用闭包，但是它们生成了很多我不想粘贴到此处的样板代码。

最后的评论

您将局部变量和参数传递到名为 的方法中GetMemberName。幸运的是，两个编译器首先自动生成类型和成员来满足 linq 表达式树。幸运的是，最新版本的编译器具有 nameof 运算符，这是处理此问题的更好方法。