.net - off - customerrors mode= on

¿Cómo muestra el código de pantalla "Pantalla amarilla de la muerte" de ASP.NET?

Question

Pensé que el código .NET se compila en MSIL, así que siempre me pregunté cómo crearía Yellow Screens el código defectuoso. Si está ejecutando el código compilado, ¿cómo puede el compilador generar código a partir de los archivos fuente en el mensaje de error?

Siéntete libre de editar esta pregunta / título, sé que realmente no tiene sentido.

Answer 1

Creo que esto se debe a la información de depuración que se puede incluir con los ensamblados compilados ... (aunque definitivamente podría estar equivocado)

Answer 2

Creo que la información que mapea la fuente al MSIL se almacena en el archivo PDB. Si esto no está presente, entonces ese mapeo no ocurrirá.

Es esta búsqueda la que hace que una excepción sea una operación tan costosa ("las excepciones son para situaciones excepcionales").

Answer 3

Creo que los archivos pdb que salen cuando haces una compilación de depuración contienen una referencia a la ubicación de los archivos de código fuente.

Answer 4

Me gusta esto. He hecho algunos cambios, pero está muy cerca de lo que está haciendo exactamente.

// reverse the stack
private static Stack<Exception> GenerateExceptionStack(Exception exception)
{
    var exceptionStack = new Stack<Exception>();

    // create exception stack
    for (Exception e = exception; e != null; e = e.InnerException)
    {
        exceptionStack.Push(e);
    }

    return exceptionStack;
}

// render stack
private static string GenerateFormattedStackTrace(Stack<Exception> exceptionStack)
{
    StringBuilder trace = new StringBuilder();

    try
    {
        // loop through exception stack
        while (exceptionStack.Count != 0)
        {
            trace.Append("/r/n");

            // render exception type and message
            Exception ex = exceptionStack.Pop();
            trace.Append("[" + ex.GetType().Name);
            if (!string.IsNullOrEmpty(ex.Message))
            {
                trace.Append(":" + ex.Message);
            }
            trace.Append("]/r/n");

            // Load stack trace
            StackTrace stackTrace = new StackTrace(ex, true);
            for (int frame = 0; frame < stackTrace.FrameCount; frame++)
            {
                StackFrame stackFrame = stackTrace.GetFrame(frame);
                MethodBase method = stackFrame.GetMethod();
                Type declaringType = method.DeclaringType;
                string declaringNamespace = "";

                // get declaring type information
                if (declaringType != null)
                {
                    declaringNamespace = declaringType.Namespace ?? "";
                }

                // add namespace
                if (!string.IsNullOrEmpty(declaringNamespace))
                {
                    declaringNamespace += ".";
                }

                // add method
                if (declaringType == null)
                {
                    trace.Append(" " + method.Name + "(");
                }
                else
                {
                    trace.Append(" " + declaringNamespace + declaringType.Name + "." + method.Name + "(");
                }

                // get parameter information
                ParameterInfo[] parameters = method.GetParameters();
                for (int paramIndex = 0; paramIndex < parameters.Length; paramIndex++)
                {
                    trace.Append(((paramIndex != 0) ? "," : "") + parameters[paramIndex].ParameterType.Name + " " + parameters[paramIndex].Name);
                }
                trace.Append(")");


                // get information
                string fileName = stackFrame.GetFileName() ?? "";

                if (!string.IsNullOrEmpty(fileName))
                {
                    trace.Append(string.Concat(new object[] { " in ", fileName, ":", stackFrame.GetFileLineNumber() }));
                }
                else
                {
                    trace.Append(" + " + stackFrame.GetNativeOffset());
                }

                trace.Append("/r/n");
            }
        }
    }
    catch
    {
    }

    if (trace.Length == 0)
    {
        trace.Append("[stack trace unavailable]");
    }

    // return html safe stack trace
    return HttpUtility.HtmlEncode(trace.ToString()).Replace(Environment.NewLine, "<br>");
}

Answer 5

Un ensamblado .Net se compila con metadatos sobre el bytecode incluido que permite la fácil descompilación del código, así es como funcionan herramientas como .Net Reflector . Los archivos PDB solo son símbolos de depuración: la diferencia en la pantalla amarilla de la muerte es que obtendrá números de línea en el seguimiento de la pila.

En otras palabras, obtendrá el código, incluso si faltan los archivos PDB.