C# 4.0 表达式Lambda Func到c中的字符串#

我想获取lambdaFunc表达式的字符串表示形式，以获取属性路径。我有这个例子

Expression<Func<Employee, object>> _xxx = e => e.EmployeeInfo.Addresses["Address"];

当我做\u xxx.ToString（）我只需要做一些字符串解析，就可以得到上面的结果

我的问题是当我这样做的时候

var _addrName = "Address";
Expression<Func<Employee, object>> _xxx = e => e.EmployeeInfo.Addresses[_addrName];

var\u addrName=“地址”；
表达式xxx=e=>e.EmployeeInfo.Addresses[addrName]；

我有一根很长的绳子

"EmployeeInfo.Addresses.get_Item(value(UnitTestProj.UnitTest.AnyTest+<>c__DisplayClass0)._addr)"

“EmployeeInfo.Addresses.get\u项（值（UnitTestProj.UnitTest.AnyTest+c\u DisplayClass0）。\u addr”

这是很难控制的 “EmployeeInfo.Addresses[“Address”]”

有什么方法可以达到我的目的吗

---

TIA

这应该会让你走得很远-这很有意思，但我认为没有办法解决：

Expression<Func<Employee, object>> _xxx = e => e.EmployeeInfo.Addresses[address];
WriteLine(ExprToString(_xxx)); //e.EmployeeInfo.Addresses[address]

_xxx = x => x.EmployeeInfo.Addresses["XYZ"]; 
WriteLine(ExprToString(_xxx)); //x.EmployeeInfo.Addresses["XYZ"]

_xxx = y => y.EmployeeInfo.Addresses[null];
WriteLine(ExprToString(_xxx)); //y.EmployeeInfo.Addresses[null]

_xxx = z => z.EmployeeInfo.Name;
WriteLine(ExprToString(_xxx)); //z.EmployeeInfo.Name

_xxx = z => z.EmployeeInfo.GetSalary();
WriteLine(ExprToString(_xxx)); //z.EmployeeInfo.GetSalary()

_xxx = z => z.EmployeeInfo.Addresses.Select(a => a.Street);
WriteLine(ExprToString(_xxx)); //z.EmployeeInfo.Addresses.Select(a.Street)

_xxx = z => z.EmployeeInfo.Array[3];
WriteLine(ExprToString(_xxx)); //z.EmployeeInfo.Array[3]

表达式xxx=e=>e.EmployeeInfo.Addresses[address]；
WriteLine（ExprToString（xxx））//e、 EmployeeInfo.地址[地址]
_xxx=x=>x.EmployeeInfo.Addresses[“XYZ”]；
WriteLine（ExprToString（xxx））//x、 雇员信息地址[“XYZ”]
_xxx=y=>y.EmployeeInfo.Addresses[null]；
WriteLine（ExprToString（xxx））//y、 EmployeeInfo.Addresses[空]
_xxx=z=>z.EmployeeInfo.Name；
WriteLine（ExprToString（xxx））//z、 EmployeeInfo.Name
_xxx=z=>z.EmployeeInfo.GetSalary（）；
WriteLine（ExprToString（xxx））//z、 EmployeeInfo.GetSalary（）
_xxx=z=>z.EmployeeInfo.Addresses.Select（a=>a.Street）；
WriteLine（ExprToString（xxx））//z、 EmployeeInfo.Addresses.选择（a.Street）
_xxx=z=>z.EmployeeInfo.Array[3]；
WriteLine（ExprToString（xxx））//z、 EmployeeInfo.Array[3]

实施：

    static string ExprToString(Expression expr)
{
    switch (expr.NodeType)
    {
        case ExpressionType.Lambda:
            //x => (Something), return only (Something), the Body
            return ExprToString(((LambdaExpression) expr).Body);
        case ExpressionType.Convert:
        case ExpressionType.ConvertChecked:
            //type casts are not important
            return ExprToString(((UnaryExpression) expr).Operand);
        case ExpressionType.Call:
            //method call can be an Indexer (get_Item), 
            var callExpr = (MethodCallExpression) expr;
            if (callExpr.Method.Name == "get_Item")
            {
                //indexer call
                return ExprToString(callExpr.Object) + "[" + string.Join(",", callExpr.Arguments.Select(ExprToString)) + "]";
            }
            else
            {
                //method call
                var arguments = callExpr.Arguments.Select(ExprToString).ToArray();
                string target;
                if (callExpr.Method.IsDefined(typeof (ExtensionAttribute), false))
                {
                    //extension method
                    target = string.Join(".",  arguments[0], callExpr.Method.Name);
                    arguments = arguments.Skip(1).ToArray();
                }
                else if (callExpr.Object == null)
                {
                    //static method
                    target = callExpr.Method.Name;
                }
                else
                {
                    //instance method
                    target = string.Join(".", ExprToString(callExpr.Object), callExpr.Method.Name);
                }
                return target + "(" + string.Join(",", arguments) + ")";
            }
        case ExpressionType.MemberAccess:
            //property or field access
            var memberExpr = (MemberExpression) expr;
            if (memberExpr.Expression.Type.Name.Contains("<>")) //closure type, don't show it.
            {
                return memberExpr.Member.Name;
            }
            else
            {
                return string.Join(".", ExprToString(memberExpr.Expression), memberExpr.Member.Name);
            }
    }
    //by default, show the standard implementation
    return expr.ToString();
}

静态字符串ExprToString（表达式expr）
{
开关（扩展节点类型）
{
大小写表达式类型。Lambda：
//x=>（某物），仅返回（某物），主体
返回ExprToString（（（LambdaExpression）expr.Body）；
大小写表达式类型。转换：
case ExpressionType.ConvertChecked：
//类型转换并不重要
返回ExprToString（（（UnaryExpression）expr）.Operand）；
大小写表达式类型。调用：
//方法调用可以是索引器（get_Item），
var callExpr=（MethodCallExpression）expr；
if（callExpr.Method.Name==“获取项目”）
{
//索引器调用
返回ExprToString（callExpr.Object）+“[”+string.Join（“，”，callExpr.Arguments.Select（ExprToString））+”]；
}
其他的
{
//方法调用
var arguments=callExpr.arguments.Select（ExprToString.ToArray（）；
字符串目标；
if（callExpr.Method.IsDefined（typeof（ExtensionAttribute），false））
{
//扩展方法
target=string.Join（“.”，参数[0]，callExpr.Method.Name）；
arguments=arguments.Skip（1）.ToArray（）；
}
else if（callExpr.Object==null）
{
//静态法
target=callExpr.Method.Name；
}
其他的
{
//实例方法
target=string.Join（“.”，ExprToString（callExpr.Object），callExpr.Method.Name）；
}
返回目标+”（“+string.Join（“，”，参数）+”）；
}
case ExpressionType.MemberAccess：
//属性或字段访问
var memberExpr=（MemberExpression）expr；
如果（memberExpr.Expression.Type.Name.Contains（“”）//闭包类型，则不显示它。
{
返回memberExpr.Member.Name；
}
其他的
{
返回string.Join（“.”，ExprToString（memberExpr.Expression），memberExpr.Member.Name）；
}
}
//默认情况下，显示标准实现
返回expr.ToString（）；
}

您好，谢谢您的回复。那是什么$“”@Bas你在这里用的是C 6.0（代码）我用的是C 4.0哦，天哪，我太过时了。除声明的索引var\u addrName=“Address”外，它正在工作；表达式xxx=e=>e.EmployeeInfo.Addresses[addrName]；我需要EmployeeInfo.Addresses[“Address”]此字符串地址来自声明的_addrName变量

    static string ExprToString(Expression expr)
{
    switch (expr.NodeType)
    {
        case ExpressionType.Lambda:
            //x => (Something), return only (Something), the Body
            return ExprToString(((LambdaExpression) expr).Body);
        case ExpressionType.Convert:
        case ExpressionType.ConvertChecked:
            //type casts are not important
            return ExprToString(((UnaryExpression) expr).Operand);
        case ExpressionType.Call:
            //method call can be an Indexer (get_Item), 
            var callExpr = (MethodCallExpression) expr;
            if (callExpr.Method.Name == "get_Item")
            {
                //indexer call
                return ExprToString(callExpr.Object) + "[" + string.Join(",", callExpr.Arguments.Select(ExprToString)) + "]";
            }
            else
            {
                //method call
                var arguments = callExpr.Arguments.Select(ExprToString).ToArray();
                string target;
                if (callExpr.Method.IsDefined(typeof (ExtensionAttribute), false))
                {
                    //extension method
                    target = string.Join(".",  arguments[0], callExpr.Method.Name);
                    arguments = arguments.Skip(1).ToArray();
                }
                else if (callExpr.Object == null)
                {
                    //static method
                    target = callExpr.Method.Name;
                }
                else
                {
                    //instance method
                    target = string.Join(".", ExprToString(callExpr.Object), callExpr.Method.Name);
                }
                return target + "(" + string.Join(",", arguments) + ")";
            }
        case ExpressionType.MemberAccess:
            //property or field access
            var memberExpr = (MemberExpression) expr;
            if (memberExpr.Expression.Type.Name.Contains("<>")) //closure type, don't show it.
            {
                return memberExpr.Member.Name;
            }
            else
            {
                return string.Join(".", ExprToString(memberExpr.Expression), memberExpr.Member.Name);
            }
    }
    //by default, show the standard implementation
    return expr.ToString();
}