How to take the name of a variable within a method?

Question

I need to access the name of a variable within a method.

Example:

public class A
{
   public A()
   {
     string nameToWrite = "thisdoesntmatter";
     B.GetName(nameToWrite);
   }
}

public class B
{
   public static GetName(string nameIrrelevant)
   {
      Console.WriteLine(nameof(nameIrrelevant));
   }
}

But the return is this:

nameIrrelevant

And I wish it were:

nameToWrite

Answer 1

You’re talking about local variables and these are just nicknames for memory addresses totally unnecessary for execution, it’s just an abstraction to facilitate the programmer’s understanding.

After compilation there is no variable name (local, in languages/implementations that are 100% native and static, even non-local symbols can be dropped), so there is nothing to access. If the exercise asks for exactly this, and I don’t think it does, which is misinterpretation, the exercise is flawed and makes no sense. If it’s not a drill, there’s something very wrong.

What you can do is put a parameter in the method and pass the name as string as argument for the method. Even this makes no sense.

Remembering that you always know the name of variables local during development, so it makes no sense to create a code to find out what the name is.

Even the nameof() only exists as a protective measure to prevent code from de-synchronizing with the text used, so if you rename the variable, compile the nameof() will fail and you can change manually agreeing that now the other name is correct. When you use the string with the variable name, if you had a "x", and the variable changes to y, the code gets "x" and may not be noticed. In practice this operator does nothing real in the application.

It makes no sense to know the name of the variable that was used to call the method, it has zero benefits in it. Nor should it have any. The only languages that make sense are the ones that have dynamic scope, which is one of the most idiotic ideas ever created in computing, and I can talk about that because I’ve worked with language like that, but luckily today it’s optional, and even when it was mandatory to do so it was better to pretend that it could not even take advantage of this.

So you don’t have to go by this name. And if you really needed to, you should justify it. Who knows is an XY problem (see next if you are reading this during Cup :D ). This method getName() is simply unnecessary and a programming error. So it may have some relevance, yet weird:

public class A {
    public A() {
        var nameToWrite = "thisdoesntmatter";
        B.WriteName(nameof(nameToWrite));
    }
}

public class B {
    public static WriteName(string name) => WriteLine(name));
}

I put in the Github for future reference.

Note that I even changed the name of the method to make sense, and it should only exist as abstraction.

This is the same thing:

public A() {
    var nameToWrite = "thisdoesntmatter";
    WriteLine("nameToWrite"); //o nameof() daria mais proteção contra alteração desavisada
}