c# - tengo - como saber donde trabaja una persona por su nombre

Cómo encontrar el nombre COMPLETO del método de llamada C#

Question

¿Cómo puedo encontrar el nombre completo de un método de llamada en c #? He visto soluciones:

¿Cómo puedo obtener los métodos de llamada en C #

¿Cómo puedo encontrar el método que llamó al método actual?

Obtener el nombre de la función de llamada de la función llamada

Pero solo me dan el nivel superior. Considera el ejemplo:

namespace Sandbox
{
    class Program
    {
        static void Main(string[] args)
        {
            test();
        }

        static void test()
        {
            var stackTrace = new StackTrace();
            var methodBase = stackTrace.GetFrame(1).GetMethod();
            Console.WriteLine(methodBase.Name);
        }
    }
}

Esto simplemente muestra ''Main''. ¿Cómo puedo imprimirlo ''Sandbox.Program.Main''?

Antes de que alguien comience a preguntar por qué necesito usar esto, es para un marco de registro simple en el que estoy trabajando.

EDITAR

Agregando a la respuesta de Matzi:

Aquí está la solución:

namespace Sandbox
{
    class Program
    {
        static void Main(string[] args)
        {
            test();
        }

        static void test()
        {
            var stackTrace = new StackTrace();
            var methodBase = stackTrace.GetFrame(1).GetMethod();
            var Class = methodBase.ReflectedType;
            var Namespace = Class.Namespace;         //Added finding the namespace
            Console.WriteLine(Namespace + "." + Class.Name + "." + methodBase.Name);
        }
    }
}

Produce ''Sandbox.Program.Main'' como debería

Answer 1

Con este método puede obtener de forma fiable el nombre completo

    public void HandleException(Exception ex, [CallerMemberName] string caller = "")
    {
        if (ex != null)
        {
            while (ex.InnerException != null)
                ex = ex.InnerException;

            foreach (var method in new StackTrace().GetFrames())
            {
                if (method.GetMethod().Name == caller)
                {
                    caller = $"{method.GetMethod().ReflectedType.Name}.{caller}";
                    break;
                }
            }

            Console.WriteLine($"Exception: {ex.Message} Caller: {caller}()");
        }
    }

Answer 2

Creo que la mejor manera de obtener el nombre completo es:

 this.GetType().FullName + "." + System.Reflection.MethodBase.GetCurrentMethod().Name;

o prueba esto

string method = string.Format("{0}.{1}", MethodBase.GetCurrentMethod().DeclaringType.FullName, MethodBase.GetCurrentMethod().Name);  

y si desea mostrar la llamada a la función más reciente, puede utilizar:

StackTrace st  = new StackTrace(); 
StackFrame sf  = st.GetFrame(0);
var methodName = sf.GetMethod();

, pero si desea mostrar el árbol de funciones de llamada, puede hacerlo así:

if (st.FrameCount >1)
{
     // Display the highest-level function call 
     // in the trace.
     StackFrame sf = st.GetFrame(st.FrameCount-1);
     Console.WriteLine("  Original function call at top of call stack):");
     Console.WriteLine("      {0}", sf.GetMethod());
}

para más info

Answer 3

En el método GetCurrentMethod System.Reflection.MethodBase , puede encontrar información completa sobre la pila de llamadas mediante clases, etc.

Answer 4

Esto es algo así como here .

MethodBase method = stackTrace.GetFrame(1).GetMethod();
string methodName = method.Name;
string className = method.ReflectedType.Name;

Console.WriteLine(className + "." + methodName);

Answer 5

espacio de nombres de llamada actual que no es igual al espacio de nombres actual

    var mNamespace = new StackTrace().GetFrames()?.Select(x =>
                {
                    try
                    {
                        return x.GetMethod().ReflectedType?.Namespace;
                    }
                    catch (Exception)
                    {
                        return string.Empty;
                    }
                }).First(x => x != new StackTrace().GetFrame(0).GetMethod().ReflectedType?.Namespace);