Obtenir le nom de la variable renvoyant l'objet en C#

Question

Est-il possible d'obtenir le nom de la variable à l'aide de laquelle l'objet a été appelé en C#? Ou est-il possible d'obtenir toutes les variables qui concernent un objet particulier?

EDIT: Juste pour clarifier plus loin même si cela a été répondu.

Tenir compte l'exemple de code donné par Fredrik Mörk

User someUser = new User(); 
User anotherVariable = someUser; 

i.Is il possible de trouver someUser en utilisant l'objet reffered par anotherVariable.
ii. Est-il possible de trouver le nom de la variable à l'aide de laquelle l'objet a été appelé. C'est quelque chose comme someUser.getName() devrait donner "someUser" en sortie.

Merci ...

Answer 1

Non, il n'y a pas de support pour cela. Bien sûr, si vous avez un ensemble de variables "candidates" (par exemple "trouvez toutes les variables d'instance dans ce type, voici un tas d'objets de ce type"), vous pouvez vérifier si certaines d'entre elles font référence à une valeur spécifique. Mais sinon, non.

Answer 2

Je ne suis pas sûr que je comprends votre question, mais je l'interprète ainsi:

User someUser = new User(); 
User anotherVariable = someUser; 

Maintenant, vous voulez trouver someUser en utilisant l'objet référencé par anotherVariable (ce qui est l'objet utilisateur à l'origine affecté à someUser). Si c'est la question, la réponse est non, ce n'est pas possible (AFAIK).

Answer 3

Vous pouvez le faire en utilisant la réflexion pour parcourir la hiérarchie d'objets et rechercher les champs qui référencent l'objet que vous recherchez. Voici une fonction que j'utilise pour accomplir ceci. Vous devez fournir un objet racine pour sa recherche. Cela pourrait probablement être amélioré si vous pouvez regarder le cadre de la pile racine et y balayer les variables locales, mais à mes fins, l'application connaît généralement l'objet racine le plus important.

// Spew all references to obj throughout the object hierarchy. 
public static void FindReferences(object appRootObject, object obj) 
{ 
    Stack<ReferencePath> stack = new Stack<ReferencePath>(); 
    FindReferences_R(stack, appRootObject, obj); 
} 

struct ReferencePath 
{ 
    public ReferencePath(object parentObj, FieldInfo parentField) 
    { 
     m_ParentObject = parentObj; 
     m_ParentField = parentField; 
    } 

    public object m_ParentObject; 
    public FieldInfo m_ParentField; 
} 

static void PrintReferencePath(Stack<ReferencePath> stack) 
{ 
    string s = "RootObject"; 
    foreach (ReferencePath path in stack.ToArray().Reverse()) 
    { 
     s += "." + path.m_ParentField.Name; 
    } 
    System.Console.WriteLine(s); 
} 

static bool StackContainsParent(Stack<ReferencePath> stack, object obj) 
{ 
    foreach (ReferencePath path in stack) 
    { 
     if (path.m_ParentObject == obj) 
      return true; 
    } 

    return false; 
} 

static void FindReferences_R(Stack<ReferencePath> stack, object curParent, object obj) 
{ 
    Type parentType = curParent.GetType(); 

    foreach (MemberInfo memberInfo in parentType.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) 
    { 
     FieldInfo fieldInfo = memberInfo as FieldInfo; 
     if (fieldInfo == null) 
      continue; 

     Type fieldType = fieldInfo.FieldType; 
     if (!fieldType.IsClass) 
      continue; 

     object value = fieldInfo.GetValue(curParent); 
     if (value == null) 
      continue; 

     stack.Push(new ReferencePath(curParent, fieldInfo)); 
     if (value == obj) 
     { 
      PrintReferencePath(stack); 
     } 

     // Recurse, but don't recurse forever. 
     if (!StackContainsParent(stack, value)) 
     { 
      FindReferences_R(stack, value, obj); 
     } 

     stack.Pop(); 
    } 
}