主页 / 问题 / 685677
Accepted
MihailPw
Asked:2020-06-30 20:48:31 +0000 UTC2020-06-30 20:48:31 +0000 UTC

如何在函数中获取变量名

  • 772

如何在被调用的方法中获取传递的变量的名称？
仅作为附加参数传递？
也许有一些模拟CallerMemberNameAttribute只是为了获取传递的变量的名称？

例如：

var variable = "some_value"; // имя переменной nameof(variable)
DoAction(variable);


public void DoAction(string value)
{
    var valueVariableName = ... // хочу получить имя переменной ("variable")
}

如有任何想法，我将不胜感激。

注意：最初它被设想做类似的事情

public void DoAction(string value, [PreviousParameterName] string valueParameterName = null)
{
    var valueParameterName = ... // имя переменной (== "variable")
}

但是在弄清了创建自定义属性（在编译时解决）的问题之后，很明显这是不可能做到的。当然，不建议使用反射来解决这个问题（也许它甚至不起作用，我不明白）。

c#

3 个回答

  1. 例如，像这样：

    static void Main(string[] args)
{
    var world = "Hello, {0}!";
    DoAction(() => world);
}

static void DoAction(Expression<Func<string>> value)
{
    var me = (MemberExpression)value.Body;
    var variableName = me.Member.Name;
    var variableValue = value.Compile()();

    Console.WriteLine(variableValue, variableName);
}

    但它会慢慢起作用。同样，任何其他类似的“技术”都会运行缓慢。仅仅因为您可以说服编译器仅通过将变量的名称转换为字段或属性来保存它——并且没有办法从对象中快速获取名称未知的字段的值。

    • 11

  2. 如果你不是无条件地需要一个变量名，而只是在特殊情况下用于调试目的，那么如果你有调试符号，你可以尝试从源代码中获取它。

    例如，像这样：

    static void Main(string[] args)
{
    string foobarbaz = null;
    Assert(foobarbaz != null);
    Assert(false);
    Assert(true && (false || new[] { true, false }[1]));
    Assert(false /* || true*/);
    Assert(
        false // || true
    );
    Assert /*trap*/ (false);
    Assert($"{{" == null);
}

[Conditional("DEBUG"), MethodImpl(MethodImplOptions.NoInlining)]
static void Assert(bool expression)
{
    if (expression) return;

    string expression_raw;
    var frame = new StackTrace(fNeedFileInfo: true).GetFrame(1);
    try
    {
        using (var file = File.OpenText(frame.GetFileName()))
        {
            for (int k = frame.GetFileLineNumber() - 1; k > 0; k--) file.ReadLine();
            for (int k = frame.GetFileColumnNumber() - 1; k > 0; k--) file.Read();

            var parser = new Parser(file);
            parser.Ensure(nameof(Assert));
            parser.ReadUntil('(');
            parser.Ensure("(");
            parser.BeginRecord();
            parser.ReadUntil(')');
            expression_raw = parser.EndRecord();
        }
    }
    catch (IOException)
    {
        expression_raw = "";
    }

    Console.WriteLine($"Assertion {expression_raw.Trim()} failed at {frame.ToString()}");
}

private class Parser
{
    private readonly TextReader input;
    private StringBuilder output;
    private char current, prev;

    public Parser(TextReader input)
    {
        this.input = input;
    }

    public void BeginRecord()
    {
        output = new StringBuilder();
    }
    public string EndRecord()
    {
        var result = output.ToString();
        output = null;
        return result;
    }

    private char Read()
    {
        var c = input.Read();
        if (c == -1) throw new EndOfStreamException();

        prev = current;
        current = (char)c;

        output?.Append(char.IsWhiteSpace(current) ? ' ' : current);
        return current;
    }

    public void Ensure(string v)
    {
        foreach (var c in v)
        {
            if (Read() != c) throw new IOException();
        }
    }

    public void ReadUntil(char end)
    {
        while (input.Peek() != end)
        {
            switch (Read())
            {
                case '(': ReadUntil(')'); Read(); break;
                case '[': ReadUntil(']'); Read(); break;
                case '{': ReadUntil('}'); Read(); break;
                case '\'': ReadCharacter(); if (Read() != '\'') throw new IOException(); break;
                case '"': ReadString(formattable: prev == '$'); Read(); break;

                case '/':
                    if (prev == '/')
                    {
                        do { Read(); } while (current != '\n' && current != '\r');
                    }
                    break;

                case '*':
                    if (prev == '/')
                    {
                        current = '\0';
                        do { Read(); } while (prev != '*' || current != '/');
                        current = '\0';
                    }
                    break;
            }
        }
    }

    private void ReadCharacter()
    {
        if (Read() == '\\') Read();
    }

    private void ReadString(bool formattable)
    {
        while (input.Peek() != '"')
        {
            if (formattable && input.Peek() == '{')
            {
                Read();
                if (input.Peek() != '{')
                {
                    ReadUntil('}');
                }
                Read();
                continue;
            }

            ReadCharacter();
        }
    }
}
    • 9
  3. Best Answer

    C# 8.0 将带来一个新属性：

    CallerArgumentExpression

    使用它，您可以获得传递的变量的名称。

    引用我在这里给出的答案：

    如果方法声明如下：

    public static class Debug
{
     public static void Assert(bool condition, [CallerArgumentExpression("condition")] string message = null);
}

    并这样称呼：

    Debug.Assert(someBoolean);
Debug.Assert(array != null);
Debug.Assert(array.Length == 1);

    ，然后编译器将替换第二个参数的值：

    Debug.Assert(someBoolean, "someBoolean");
Debug.Assert(array != null, "array != null");
Debug.Assert(array.Length == 1, "array.Length == 1");

    因此，性能不会下降，因为这将在编译阶段完成。

    • 5

相关问题