.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.