private void PrintException(Exception ex, List <GeneratedCode> generatedCodes)
{
var frames = new List <Interface.StackFrame>();
var stackTrace = new StackTrace(ex, true);
for (int i = 0; i < stackTrace.FrameCount; ++i)
{
System.Diagnostics.StackFrame diagnosticFrame = stackTrace.GetFrame(i);
// Extract method name
MethodBase method = diagnosticFrame.GetMethod();
// Note(Maik): Skip internal render methods in case of a stack trace.
if (Attribute.IsDefined(method, typeof(HideStackTraceAttribute)))
{
continue;
}
Type declaringType = method.DeclaringType;
var methodSb = new StringBuilder();
if (declaringType != null)
{
methodSb.Append(declaringType.FullName).Append(".");
}
methodSb.Append(method.Name);
// Extract original filename, line and column
int?line = null;
if (diagnosticFrame.GetFileLineNumber() != 0)
{
line = diagnosticFrame.GetFileLineNumber();
}
int?column = null;
if (diagnosticFrame.GetFileColumnNumber() != 0)
{
column = diagnosticFrame.GetFileColumnNumber();
}
string filename = diagnosticFrame.GetFileName();
GeneratedCode generatedCode = generatedCodes.FirstOrDefault(gcode => string.Compare(gcode.TemplatePath, filename, StringComparison.OrdinalIgnoreCase) == 0);
if ((generatedCode != null) && (line != null))
{
var position = new TextPosition(line.Value, column ?? 1);
TextFilePosition original = generatedCode.SourceMap.FindSourceByGenerated(position);
if (original.IsValid)
{
filename = original.Name;
line = original.Line;
column = original.Column;
}
}
var msgFrame = new Interface.StackFrame(methodSb.ToString(), filename, line, column);
frames.Add(msgFrame);
} // for
this.MessageHandler.Message(TraceLevel.Error, $"{ex.GetType().FullName}: {ex.Message}", string.Empty, new TextPosition());
this.MessageHandler.StackTrace(frames);
}
public ConeStackFrame(StackFrame frame)
{
Method = frame.GetMethod();
File = frame.GetFileName();
Line = frame.GetFileLineNumber();
Column = frame.GetFileColumnNumber();
}
/// <summary>
/// Initializes a new instance of the <see cref="ExceptionFrame"/> class.
/// </summary>
/// <param name="frame">The <see cref="StackFrame"/>.</param>
public ExceptionFrame(StackFrame frame)
{
if (frame == null)
return;
int lineNo = frame.GetFileLineNumber();
if (lineNo == 0)
{
//The pdb files aren't currently available
lineNo = frame.GetILOffset();
}
var method = frame.GetMethod();
if (method != null)
{
Module = (method.DeclaringType != null) ? method.DeclaringType.FullName : null;
Function = method.Name;
Source = method.ToString();
}
else
{
// on some platforms (e.g. on mono), StackFrame.GetMethod() may return null
// e.g. for this stack frame:
// at (wrapper dynamic-method) System.Object:lambda_method (System.Runtime.CompilerServices.Closure,object,object))
Module = "(unknown)";
Function = "(unknown)";
Source = "(unknown)";
}
Filename = frame.GetFileName();
LineNumber = lineNo;
ColumnNumber = frame.GetFileColumnNumber();
}
public void FileName_LineNumber_ColumnNumber ()
{
StackFrame sf = new StackFrame (String.Empty, Int32.MinValue, Int32.MaxValue);
Assert.AreEqual (Int32.MinValue, sf.GetFileLineNumber (), "GetFileLineNumber");
Assert.AreEqual (Int32.MaxValue, sf.GetFileColumnNumber (), "GetFileColumnNumber");
Assert.IsTrue (sf.GetILOffset () >= 0, "GetILOffset");
Assert.IsTrue (sf.GetNativeOffset () > 0, "GetNativeOffset");
Assert.AreEqual ("FileName_LineNumber_ColumnNumber", sf.GetMethod ().Name, "GetMethod");
}
public void Default ()
{
StackFrame sf = new StackFrame ();
Assert.AreEqual (0, sf.GetFileLineNumber (), "GetFileLineNumber");
Assert.AreEqual (0, sf.GetFileColumnNumber (), "GetFileColumnNumber");
Assert.IsTrue (sf.GetILOffset () >= 0, "GetILOffset");
Assert.IsTrue (sf.GetNativeOffset () >= 0, "GetNativeOffset");
Assert.AreEqual ("Default", sf.GetMethod ().Name, "GetMethod");
}
/// <summary>
/// Creates a new instance of the <see cref="WcfRawJson.ErrorHandling.FaultStackFrame"/>
/// class from an existing <see cref="System.Diagnostics.StackFrame"/>.
/// </summary>
/// <param name="frame">
/// The <see cref="System.Diagnostics.StackFrame"/> object from which to derive this
/// <see cref="WcfRawJson.ErrorHandling.StackFrame"/>
/// </param>
public FaultStackFrame(StackFrame frame)
{
this.FileColumnNumber = frame.GetFileColumnNumber();
this.FileLineNumber = frame.GetFileLineNumber();
this.FileName = frame.GetFileName();
this.ILOffset = frame.GetILOffset();
this.Method = frame.GetMethod().ToString();
this.NativeOffset = frame.GetNativeOffset();
this.Description = frame.ToString();
}
public static void assert(bool pCondition)
{
if (!pCondition)
{
StackFrame frame = new StackFrame(1, true);
var message = string.Format("Line: {0}\r\nColumn: {1}\r\nWhere:{2}",
frame.GetFileLineNumber(),
frame.GetFileColumnNumber(),
frame.GetMethod().Name);
throw new Exception(message);
}
}
public static void isNull(object pObject)
{
if (pObject == null)
{
StackFrame frame = new StackFrame(1, true);
var message = string.Format("Line: {0}\r\nColumn: {1}\r\nWhere:{2}",
frame.GetFileLineNumber(),
frame.GetFileColumnNumber(),
frame.GetMethod().Name);
throw new NullReferenceException(message);
}
}
// avoid replication of tests on all constructors (this is no
// problem because the stack is already set correctly). The
// goal is to call every property and methods to see if they
// have any* security requirements (*except for LinkDemand and
// InheritanceDemand).
private void Check (StackFrame sf, bool checkFile)
{
int cn = sf.GetFileColumnNumber ();
int ln = sf.GetFileLineNumber ();
int il = sf.GetILOffset ();
int no = sf.GetNativeOffset ();
Assert.IsNotNull (sf.GetMethod (), "GetMethod");
if (checkFile) {
string fn = sf.GetFileName ();
}
}
public static string StackFrameToString(StackFrame stackFrame)
{
StringBuilder sb = new StringBuilder();
int intParam; MemberInfo mi = stackFrame.GetMethod();
sb.Append(" ");
sb.Append(mi.DeclaringType.Namespace);
sb.Append(".");
sb.Append(mi.DeclaringType.Name);
sb.Append(".");
sb.Append(mi.Name);
// -- build method params
sb.Append("(");
intParam = 0;
foreach (ParameterInfo param in stackFrame.GetMethod().GetParameters())
{
intParam += 1;
sb.Append(param.Name);
sb.Append(" As ");
sb.Append(param.ParameterType.Name);
}
sb.Append(")");
sb.Append(Environment.NewLine);
// -- if source code is available, append location info
sb.Append(" ");
if (string.IsNullOrEmpty(stackFrame.GetFileName()))
{
sb.Append("(unknown file)");
//-- native code offset is always available
sb.Append(": N ");
sb.Append(string.Format("{0:#00000}", stackFrame.GetNativeOffset()));
}
else
{
sb.Append(Path.GetFileName(stackFrame.GetFileName()));
sb.Append(": line ");
sb.Append(string.Format("{0:#0000}", stackFrame.GetFileLineNumber()));
sb.Append(", col ");
sb.Append(string.Format("{0:#00}", stackFrame.GetFileColumnNumber()));
if (stackFrame.GetILOffset() != StackFrame.OFFSET_UNKNOWN)
{
sb.Append(", IL ");
sb.Append(string.Format("{0:#0000}", stackFrame.GetILOffset()));
}
}
sb.Append(Environment.NewLine);
return sb.ToString();
}
public static StackFrame Create(System.Diagnostics.StackFrame frame)
{
if (frame == null)
{
return(null);
}
string fileName = null;
bool isTaskAwaiter = false;
ITypeMember member = null;
try {
fileName = frame.GetFileName();
} catch (SecurityException) {
// CAS check failure
}
var method = frame.GetMethod();
if (method != null)
{
isTaskAwaiter = method.DeclaringType.IsTaskAwaiter() ||
method.DeclaringType.DeclaringType.IsTaskAwaiter();
var property = GetPropertyForMethodAccessor(method);
if (property != null)
{
member = Property.Create(property);
}
else
{
member = Method.Create(method);
}
}
return(new StackFrame(
fileName,
frame.GetFileLineNumber(),
frame.GetFileColumnNumber(),
frame.GetILOffset(),
frame.GetNativeOffset(),
frame.GetMethodAddress(),
frame.GetMethodIndex(),
isTaskAwaiter,
ParseInternalMethodName(frame.GetInternalMethodName()),
member));
}
public static string GetStackFrameInfo(StackFrame frame, TraceInfo traceInfo)
{
if (frame != null)
{
switch (traceInfo)
{
case TraceInfo.LineNumber:
return frame.GetFileLineNumber().ToString();
case TraceInfo.FileName:
return frame.GetFileName();
case TraceInfo.Method:
return frame.GetMethod().Name;
case TraceInfo.ColumnNumber:
return frame.GetFileColumnNumber().ToString();
case TraceInfo.Full:
return new StackTrace(frame).ToString();
}
}
return "Error: StackFrame==null";
}
public override bool Equals(Object obj)
{
if ((obj == null) || (!(obj is StackFrame)))
{
return(false);
}
StackFrame rhs = (StackFrame)obj;
if (!ObjectsEqual(GetMethod(), rhs.GetMethod()))
{
return(false);
}
if (!ObjectsEqual(GetFileName(), rhs.GetFileName()))
{
return(false);
}
if (GetFileLineNumber() != rhs.GetFileLineNumber())
{
return(false);
}
if (GetFileColumnNumber() != rhs.GetFileColumnNumber())
{
return(false);
}
if (GetILOffset() != rhs.GetILOffset())
{
return(false);
}
if (GetNativeOffset() != rhs.GetNativeOffset())
{
return(false);
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="ExceptionFrame"/> class.
/// </summary>
/// <param name="frame">The <see cref="StackFrame"/>.</param>
public ExceptionFrame(StackFrame frame)
{
if (frame == null)
return;
int lineNo = frame.GetFileLineNumber();
if (lineNo == 0)
{
//The pdb files aren't currently available
lineNo = frame.GetILOffset();
}
var method = frame.GetMethod();
Filename = frame.GetFileName();
Module = (method.DeclaringType != null) ? method.DeclaringType.FullName : null;
Function = method.Name;
Source = method.ToString();
LineNumber = lineNo;
ColumnNumber = frame.GetFileColumnNumber();
}
private static ExceptionFrame BuildExceptionFrame(StackFrame frame)
{
int lineNo = frame.GetFileLineNumber();
if (lineNo == 0)
{
//The pdb files aren't currently available
lineNo = frame.GetILOffset();
}
var method = frame.GetMethod();
return new ExceptionFrame()
{
Filename = frame.GetFileName(),
Module = (method.DeclaringType != null) ? method.DeclaringType.FullName : null,
Function = method.Name,
Source = method.ToString(),
LineNumber = lineNo,
ColumnNumber = frame.GetFileColumnNumber()
};
}
public static void WriteMethodExit(Type type, StackFrame sf)
{
if (StockLog.Logger.isEnabled && StockLog.Logger.isMethodLoggingEnabled)
{
StockLog.Logger.sw.WriteLine("{0}({1},{2}): {3}::{4} : Exit", sf.GetFileName(), sf.GetFileLineNumber(), sf.GetFileColumnNumber(), type.ToString(), sf.GetMethod().Name);
}
}
public static void WriteMethodEntry(StackFrame sf)
{
if (StockLog.Logger.isEnabled && StockLog.Logger.isMethodLoggingEnabled)
{
StockLog.Logger.sw.WriteLine("{0}({1},{2}): {3} : Entry", sf.GetFileName(), sf.GetFileLineNumber(), sf.GetFileColumnNumber(), sf.GetMethod().Name);
}
}
private void output(string errorOrWarning, string message, params string[] tokens)
{
if (tokens == null || tokens.Length == 0 || tokens.All(t => t == null))
{
var frame = new StackFrame(2, true);
outputLine(errorOrWarning, frame.GetFileName(), "{0},{1}".Fmt(frame.GetFileLineNumber(), frame.GetFileColumnNumber()), message);
return;
}
try
{
var tokenRegexes = tokens.Select(tok => tok == null ? null : new Regex(@"\b" + Regex.Escape(tok) + @"\b")).ToArray();
foreach (var f in new DirectoryInfo(_path).GetFiles("*.cs", SearchOption.AllDirectories))
{
var lines = File.ReadAllLines(f.FullName);
var tokenIndex = tokens.IndexOf(t => t != null);
for (int i = 0; i < lines.Length; i++)
{
Match match;
var charIndex = 0;
while ((match = tokenRegexes[tokenIndex].Match(lines[i], charIndex)).Success)
{
do { tokenIndex++; } while (tokenIndex < tokens.Length && tokens[tokenIndex] == null);
if (tokenIndex == tokens.Length)
{
Console.Error.WriteLine(@"{0}({1},{2},{1},{3}): {4} CS9999: {5}",
f.FullName,
i + 1,
match.Index + 1,
match.Index + match.Length + 1,
errorOrWarning,
message
);
return;
}
charIndex = match.Index + match.Length;
}
}
}
}
catch (Exception e)
{
Console.Error.WriteLine("Error: " + e.Message + " (" + e.GetType().FullName + ")");
}
Console.Error.WriteLine("{0} CS9999: {1}", errorOrWarning, message);
}
/// <summary>
/// Construct a <see cref="FaultException"/> describing the server side exception <paramref name="ex"/> for
/// communication to a client.
/// </summary>
/// <param name="ex">The exception that occurred on the server</param>
/// <param name="details">Optional arbitrary data associated with the exception</param>
/// <remarks>
/// Have been playing around with this a little, to see what can be passed back to the clients. Unsuccessful
/// in transmitting inner exceptions and data dictionary in any exceptions. Not sure why. Does transmit the top
/// level exception (except for data dictionary) back to the client correctly, which will do for now.
/// - Will look into these issues some point. Without inner exceptions debugging server code can be difficult.
/// (Server does, however, write exceptions, including inner exceptions, to console for now for debug purposes)
/// </remarks>
private FaultException Error(Exception ex, params object[] details)
{
StackFrame errorFrame = new StackFrame(1, true);
MethodBase mb = errorFrame.GetMethod();
MethodBody methodBody = mb.GetMethodBody();
// ParameterInfo[] pi = mb.GetParameters();
StringBuilder action = new StringBuilder();
action.AppendFormat("{0}:{1}.{2}(", mb.DeclaringType.Assembly.GetName().Name, mb.DeclaringType.FullName, mb.Name);
// for (int i = 0; i < pi.Length; i++)
// action.AppendFormat("\n\t{0}={1}{2}{3}", pi[i].Name, details[i].ToString().Contains('\n') ? "\n\t " : "",
// details[i].ToString().Replace("\n", "\n\t "), i == pi.Length - 1 && methodBody.LocalVariables.Count == 0 ? "" : ",");
foreach (LocalVariableInfo lvInfo in methodBody.LocalVariables)
action.AppendFormat("\n\t{0}", lvInfo.ToString());
action.AppendFormat("){0}[{1}:{2},{3}]:\n{4}: {5}\n{6}\n", /*pi.Length > 0 ?*/ "\n", // : " ",
errorFrame.GetFileName(), errorFrame.GetFileLineNumber(), errorFrame.GetFileColumnNumber(),
ex.GetType().FullName, ex.Message, ex.StackTrace);
string actionStr = action.ToString();
if (Configuration.OutputExceptions)
Console.WriteLine("\n{0}\n", actionStr);
FaultException<ExceptionDetail> retEx = new FaultException<ExceptionDetail>(
new ExceptionDetail(ex), actionStr, // ex.GetType().FullName + " caught on ArtefactService",
FaultCode.CreateSenderFaultCode(errorFrame.GetMethod().Name, mb.DeclaringType.FullName),
OperationContext.Current.IncomingMessageHeaders.Action);
foreach (object detail in details)
retEx.Data.Add(retEx.Data.Count, detail);
return retEx;
}
private MongoDbLogStackFrame ToStackFrame(StackFrame stackFrame)
{
return new MongoDbLogStackFrame()
{
Column = stackFrame.GetFileColumnNumber(),
Line = stackFrame.GetFileLineNumber(),
Filename = stackFrame.GetFileName(),
MethodName = stackFrame.GetMethod().Name,
TypeName = stackFrame.GetMethod().DeclaringType.FullName
};
}
/// <summary>
/// <para>警告！！！！！！！！！！！！！！！！！！！！</para>
/// <para>这个函数请谨慎使用，会实时打印出函数调用栈信息，类似 print( Exception.stackTrace )，</para>
/// <para>调用栈目前只打印了，从调用这个函数开始的函数往下10层，并不是全部的栈信息。</para>
/// <para>本函数只在windows pc下才可以被正确执行，其余平台等于普通log</para>
/// </summary>
/// <param name="fmt"></param>
/// <param name="args"></param>
public static void LogStackTrace(string fmt, params object[] args)
{
string str = "";
if (args.Length == 0)
{
str = fmt;
}
else
{
str = string.Format(fmt, args);
}
#if UNITY_STANDALONE_WIN
str += "\n";
System.Diagnostics.StackTrace st = new System.Diagnostics.StackTrace(true);
System.Diagnostics.StackFrame frame = null;
for (int i = 1; i < 11; i++)
{
frame = st.GetFrame(i);
str += frame.GetFileName() + " - ( " + frame.GetFileLineNumber() + " , " + frame.GetFileColumnNumber() + " ) : " + frame.GetMethod().Name + " \n";
}
Debug(str);
#else
Debug(str);
#endif
}
internal void SetDebugInfo(StackFrame/*!*/ frame)
{
this.line = frame.GetFileLineNumber();
this.column = frame.GetFileColumnNumber();
this.file = frame.GetFileName();
}
public static Action<Binding[], int> CreateMethodFrame(string description, StackFrame frame)
{
lock (Module)
{
const string methodName = " ";
var className = description;
if (ClassNames.Contains(className))
{
className += " /" + ClassNames.Count;
}
ClassNames.Add(className);
var type = Module.DefineType(className, TypeAttributes.Class | TypeAttributes.Public);
var method = type.DefineMethod(methodName, MethodAttributes.Public | MethodAttributes.Static, typeof(void), new[] { typeof(Binding[]), typeof(int) });
method.SetImplementationFlags(MethodImplAttributes.NoOptimization);
var il = method.GetILGenerator();
var binding = il.DeclareLocal(typeof(Binding));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldelem_I4);
il.Emit(OpCodes.Stloc_S, binding);
var fileName = frame?.GetFileName();
if (!string.IsNullOrEmpty(fileName))
{
var symbolDocument = Module.DefineDocument(fileName, SymDocumentType.Text, SymLanguageType.CSharp, SymLanguageVendor.Microsoft);
il.MarkSequencePoint(symbolDocument, frame.GetFileLineNumber(), frame.GetFileColumnNumber(), frame.GetFileLineNumber(), frame.GetFileColumnNumber() + 2);
method.DefineParameter(1, ParameterAttributes.None, "bindings");
method.DefineParameter(2, ParameterAttributes.None, "index");
}
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, typeof(Binding[]).GetProperty("Length").GetGetMethod());
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Sub);
var lblFin = il.DefineLabel();
il.Emit(OpCodes.Bge_S, lblFin);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Ldelem_I4);
il.Emit(OpCodes.Ldfld, typeof(Binding).GetField("DebugContext"));
il.Emit(OpCodes.Callvirt, typeof(DebugContext).GetProperty("VirtualFrame").GetGetMethod());
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldc_I4_1);
il.Emit(OpCodes.Add);
il.Emit(OpCodes.Call, typeof(Action<Binding[], int>).GetMethod("Invoke"));
il.Emit(OpCodes.Ret);
il.MarkLabel(lblFin);
il.Emit(OpCodes.Ldloc, binding);
il.Emit(OpCodes.Callvirt, typeof(Binding).GetMethod("Execute"));
il.Emit(OpCodes.Ret);
if (!string.IsNullOrEmpty(fileName))
{
binding.SetLocalSymInfo("binding", 0, il.ILOffset);
}
var actualType = type.CreateType();
return (Action<Binding[], int>)actualType.GetMethod(methodName).CreateDelegate(typeof(Action<Binding[], int>));
}
}
/// <summary>
/// ログを出力します。
/// </summary>
/// <remarks>
/// メッセージには"プロセス名(プロセスID)-マネージスレッドID(ネイティブスレッドID): "が先頭に付与されます。
/// </remarks>
/// <param name="depth">ログの呼び出し元からのコールスタックの深さ</param>
/// <param name="level">ログレベル</param>
/// <param name="message">メッセージ</param>
protected void Log(int depth, LogLevel level, string message)
{
if (!this.IsEnabled(level)) return;
try
{
{
Process process;
int nativeThreadId;
int managedThreadId;
StackFrame frame;
string fileName;
int fileLineNumber;
int fileColumnNumber;
MethodBase method;
string className;
string methodName;
process = Process.GetCurrentProcess();
#pragma warning disable 618
nativeThreadId = AppDomain.GetCurrentThreadId();
#pragma warning restore 618
managedThreadId = Thread.CurrentThread.ManagedThreadId;
frame = new StackFrame(++depth);
fileName = frame.GetFileName();
if (fileName == null) fileName = "{unknown}";
fileLineNumber = frame.GetFileLineNumber();
fileColumnNumber = frame.GetFileColumnNumber();
method = frame.GetMethod();
className = method.DeclaringType.FullName;
methodName = method.Name;
if (".ctor".Equals(methodName)) methodName = "{constructor}";
message = String.Format(
"{0}({1:D})-{2:D}({3:D}): {4}::{5} ({6}:{7}-{8})\r\n{9}",
process.ProcessName, process.Id, managedThreadId, nativeThreadId,
className, methodName, fileName, fileLineNumber, fileColumnNumber,
message);
}
this.WriteLog(level, message);
}
catch (Exception)
{
#if DEBUG
throw;
#endif
}
}
/// <summary>
/// Initialises a new instance of the FieldLogStackFrame class.
/// </summary>
/// <param name="stackFrame">The StackFrame instance.</param>
public FieldLogStackFrame(StackFrame stackFrame)
{
MethodBase method = stackFrame.GetMethod();
if (method.DeclaringType != null)
{
Module = method.DeclaringType.Module.FullyQualifiedName;
Token = method.MetadataToken;
ILOffset = stackFrame.GetILOffset();
TypeName = FormatTypeName(method.DeclaringType);
}
MethodName = method.Name;
// TODO: Include 'extern' indicator from the following tests (needs new file format)
//bool isPInvoke = (method.Attributes & MethodAttributes.PinvokeImpl) != 0;
//bool isInternalCall = (method.GetMethodImplementationFlags() & MethodImplAttributes.InternalCall) != 0;
MethodInfo methodInfo = method as MethodInfo;
StringBuilder sigSb = new StringBuilder();
if (methodInfo != null)
{
sigSb.Append(FormatTypeName(methodInfo.ReturnType));
}
else
{
sigSb.Append("void"); // Dummy return value for constructors
}
ParameterInfo[] parameters = method.GetParameters();
sigSb.Append("(");
for (int i = 0; i < parameters.Length; i++)
{
if (i > 0)
{
sigSb.Append(", ");
}
sigSb.Append(FormatTypeName(parameters[i].ParameterType));
}
sigSb.Append(")");
MethodSignature = sigSb.ToString();
FileName = stackFrame.GetFileName();
Line = stackFrame.GetFileLineNumber();
Column = stackFrame.GetFileColumnNumber();
Size = (Module != null ? Module.Length * 2 : 0) +
(TypeName != null ? TypeName.Length * 2 : 0) +
(MethodName != null ? MethodName.Length * 2 : 0) +
(MethodSignature != null ? MethodSignature.Length * 2 : 0) +
(FileName != null ? FileName.Length * 2 : 0) +
4 + 4;
}
/// <summary>
/// 获取追踪信息所在列
/// </summary>
/// <param name="frame"></param>
/// <returns></returns>
public static String GetColumnNumber(StackFrame frame)
{
const String unknow = "NULL";
if (frame == null) return unknow;
var columnNumber = frame.GetFileColumnNumber();
return String.IsNullOrEmpty(columnNumber.ToString(CultureInfo.InvariantCulture))
? unknow
: columnNumber.ToString(CultureInfo.InvariantCulture);
}
private static string StackFrameToString(StackFrame sf)
{
var sb = new StringBuilder();
MemberInfo mi = sf.GetMethod();
sb.AppendFormat(" {0}.{1}.{2}",
mi.DeclaringType.Namespace,
mi.DeclaringType.Name,
mi.Name);
ParameterInfo[] parameters = sf.GetMethod().GetParameters();
sb.Append("(");
sb.Append(String.Join(", ", parameters.Select(p => String.Format("{0} {1}", p.ParameterType.Name, p.Name)).ToArray()));
sb.Append(")");
sb.AppendLine();
sb.Append(" ");
if (String.IsNullOrEmpty(sf.GetFileName()))
{
sb.Append(Path.GetFileName(ParentAssembly.CodeBase));
sb.Append(": N ");
sb.AppendFormat("{0:#00000}", sf.GetNativeOffset());
}
else
{
sb.Append(Path.GetFileName(sf.GetFileName()));
sb.AppendFormat(": line {0:#0000}, col {1:#00}", sf.GetFileLineNumber(), sf.GetFileColumnNumber());
if (sf.GetILOffset() != StackFrame.OFFSET_UNKNOWN)
{
sb.AppendFormat(", IL {0:#0000}", sf.GetILOffset());
}
}
sb.AppendLine();
return sb.ToString();
}
private static string StackFrameToString(StackFrame sf, ref string errorFrom)
{
StringBuilder sb = new StringBuilder();
int intParam;
MemberInfo mi = sf.GetMethod();
Type type = mi.DeclaringType;
string namspace = type.Namespace ?? string.Empty;
if (namspace.Equals("ExamineSystem.utility.eslog"))
{
return sb.ToString();
}
if (string.IsNullOrEmpty(errorFrom))
{
try
{
if (type.IsSubclassOf(typeof(System.Web.UI.Page)))
{
errorFrom = type.FullName;
}
else if (type.IsSubclassOf(typeof(System.Web.UI.Control)))
{
errorFrom = type.FullName;
}
else if (type.GetInterface("System.Web.IHttpHandler") != null)
{
errorFrom = type.FullName;
}
else if (type.GetInterface("System.Web.IHttpAsyncHandler") != null)
{
errorFrom = type.FullName;
}
else if (type.GetInterface("System.Web.IHttpModule") != null)
{
errorFrom = type.FullName;
}
else if (type.GetInterface("System.Web.IHttpHandlerFactory") != null)
{
errorFrom = type.FullName;
}
}
catch (Exception)
{
errorFrom = string.Empty;
}
}
sb.Append(" ");
sb.Append(namspace);
sb.Append(".");
sb.Append(type.Name);
sb.Append(".");
sb.Append(mi.Name);
// -- build method params
sb.Append("(");
intParam = 0;
foreach (ParameterInfo param in sf.GetMethod().GetParameters())
{
if (intParam > 0)
sb.Append(" , ");
sb.Append(param.Name);
sb.Append(" As ");
sb.Append(param.ParameterType.Name);
intParam += 1;
}
sb.Append(")");
sb.Append(Environment.NewLine);
// -- if source code is available, append location info
sb.Append(" ");
if (string.IsNullOrEmpty(sf.GetFileName()))
{
sb.Append("(unknown file)");
//-- native code offset is always available
sb.Append(": N ");
sb.Append(String.Format("{0:#00000}", sf.GetNativeOffset()));
}
else
{
sb.Append(System.IO.Path.GetFileName(sf.GetFileName()));
sb.Append(": line ");
sb.Append(String.Format("{0:#0000}", sf.GetFileLineNumber()));
sb.Append(", col ");
sb.Append(String.Format("{0:#00}", sf.GetFileColumnNumber()));
if (sf.GetILOffset() != StackFrame.OFFSET_UNKNOWN)
{
sb.Append(", IL ");
sb.Append(String.Format("{0:#0000}", sf.GetILOffset()));
}
}
sb.Append(Environment.NewLine);
return sb.ToString();
}
//--
//-- turns a single stack frame object into an informative string
//--
private static string StackFrameToString(StackFrame sf)
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
int intParam = 0;
MemberInfo mi = sf.GetMethod();
var _with1 = sb;
//-- build method name
_with1.Append(" ");
_with1.Append(mi.DeclaringType.Namespace);
_with1.Append(".");
_with1.Append(mi.DeclaringType.Name);
_with1.Append(".");
_with1.Append(mi.Name);
//-- build method params
ParameterInfo[] objParameters = sf.GetMethod().GetParameters();
ParameterInfo objParameter = null;
_with1.Append("(");
intParam = 0;
foreach (ParameterInfo objParameter_loopVariable in objParameters)
{
objParameter = objParameter_loopVariable;
intParam += 1;
if (intParam > 1)
_with1.Append(", ");
_with1.Append(objParameter.Name);
_with1.Append(" As ");
_with1.Append(objParameter.ParameterType.Name);
}
_with1.Append(")");
_with1.Append(Environment.NewLine);
//-- if source code is available, append location info
_with1.Append(" ");
if (sf.GetFileName() == null || sf.GetFileName().Length == 0)
{
_with1.Append(System.IO.Path.GetFileName(ParentAssembly().CodeBase));
//-- native code offset is always available
_with1.Append(": N ");
_with1.Append(string.Format("{0:#00000}", sf.GetNativeOffset()));
}
else
{
_with1.Append(System.IO.Path.GetFileName(sf.GetFileName()));
_with1.Append(": line ");
_with1.Append(string.Format("{0:#0000}", sf.GetFileLineNumber()));
_with1.Append(", col ");
_with1.Append(string.Format("{0:#00}", sf.GetFileColumnNumber()));
//-- if IL is available, append IL location info
if (sf.GetILOffset() != StackFrame.OFFSET_UNKNOWN)
{
_with1.Append(", IL ");
_with1.Append(string.Format("{0:#0000}", sf.GetILOffset()));
}
}
_with1.Append(Environment.NewLine);
return sb.ToString();
}
/// <summary>
/// Traces up the stack frame containing the method call that has caused an error.
/// </summary>
/// <returns>Found stack info.</returns>
/// <remarks>
/// Starts with a frame of a calling method and ends with the first frame belonging to user routine.
/// If there was <see cref="ImplementsFunctionAttribute"/> found during the walk the last one's value
/// is considered as the caller.
/// If there was not such attribute found (error occured in an operator, directly in the code etc.)
/// the last inspected method's debug info is returned.
/// If the trace ends up with a function or method inside transient assembly an eval hierarchy is inspected
/// and added to the resulting source position information.
/// </remarks>
internal static ErrorStackInfo TraceErrorFrame(ScriptContext/*!*/ context)
{
Debug.Assert(context != null);
ErrorStackInfo result = new ErrorStackInfo();
int cl_function_idx = -1;
string cl_function_name = null;
StackFrame frame;
int eval_id = TransientAssembly.InvalidEvalId;
// stack trace without debug info is constructed:
#if !SILVERLIGHT
StackTrace trace = new StackTrace(1, false);
// note: method stack frame contains a debug info about the call to the callee
// hence if we find a method that reported the error we should look the next frame
// to obtain a debug info
int i = 0;
for (; ; )
{
// gets frame:
frame = trace.GetFrame(i++);
// error has been thrown directly by Core without intermediary user code (all frames are invisible):
if (frame == null)
{
// cl_function_idx can be non-minus-one here because a callback can be called directly from Core
// (e.g. output buffer filter targeting class library function):
if (cl_function_idx != -1)
{
result.Caller = cl_function_name;
result.LibraryCaller = true;
}
return result;
}
FrameKinds frame_kind = GetFrameKind(frame);
if (frame_kind == FrameKinds.Visible)
{
MethodBase method = frame.GetMethod();
int eid = TransientModule.GetEvalId(context.ApplicationContext, method);
if (eval_id == TransientAssembly.InvalidEvalId)
eval_id = eid;
if (eid == TransientAssembly.InvalidEvalId)
break;
}
else if (frame_kind == FrameKinds.ClassLibraryFunction)
{
MethodBase method = frame.GetMethod();
cl_function_idx = i;
cl_function_name = ImplementsFunctionAttribute.Reflect(method).Name;
}
}
// skips i frames (the very first frame has been skipped in the previous
// trace construction and we want to skip i-1 frames from that trace => i frames totally):
frame = new StackFrame(1 + i - 1, true);
// extracts a source info (file & position):
if (eval_id != TransientAssembly.InvalidEvalId)
{
FillEvalStackInfo(context, eval_id, ref result, false);
}
else
{
result.Line = frame.GetFileLineNumber();
result.Column = frame.GetFileColumnNumber();
result.File = frame.GetFileName();
}
// determines a caller (either a library function or a user function/method):
if (cl_function_idx >= 0)
{
result.Caller = cl_function_name;
result.LibraryCaller = true;
}
//else
//{
// MethodBase method = frame.GetMethod();
// Type type = method.DeclaringType;
// // the caller has already been set by FillEvalStackInfo
// // if we are in eval and the function is Main helper of the script type:
// if (eval_id == TransientAssembly.InvalidEvalId)
// {
// result.LibraryCaller = false;
// if (type != null)
// {
// result.Caller = String.Concat(DTypeDesc.MakeFullName(type), "::", DRoutineDesc.MakeFullName(method));
// }
// else
// {
// result.Caller = DRoutineDesc.MakeFullName(method);
// }
// }
//}
#endif
// add missing info about file and line
context.LastErrorLine = result.Line;
context.LastErrorFile = result.File;
//
return result;
}
/// <summary>
/// Assert the specified condition, logging result to <see cref="AutoTraceSource.Trace"/>
/// </summary>
/// <param name="condition">Condition</param>
public void Assert(bool condition)
{
//Debug.Assert(condition);
StackFrame sf = new StackFrame(1);
if (condition)
Trace.Log(Trace.Level.Verbose, "Assert OK at {0}+{1} (in file {2}:{3},{4}", sf.GetMethod().Name,
sf.GetILOffset(), sf.GetFileName(), sf.GetFileLineNumber(), sf.GetFileColumnNumber());
else
Trace.Log(Trace.Level.Warning, "Assert FAILED at {0}+{1} (in file {2}:{3},{4})", sf.GetMethod().Name,
sf.GetILOffset(), sf.GetFileName(), sf.GetFileLineNumber(), sf.GetFileColumnNumber());
}
private static bool AreSameAddress(SourceAddress groupAddress, StackFrame frame)
{
return frame.GetFileLineNumber() - 1 == groupAddress.LineIndex
&& frame.GetFileColumnNumber() - 1 == groupAddress.ExpressionIndex
&& frame.GetFileName() == groupAddress.FileName;
}
private CallingMethodInfo getStackFrameInfo(StackFrame stackFrame, bool onlyIncludeInfoWithFileLine)
{
var methodInfo = new CallingMethodInfo { StackTrace = string.Empty };
if (stackFrame == null)
return null;
var method = stackFrame.GetMethod();
if (method == null)
return null;
method = getRealMethodFromAsyncMethod(method);
var type = method.ReflectedType;
if (type == null)
return null;
var assemblyName = method.Module.Assembly.GetName().Name;
if (_assembliesToExclude.Contains(assemblyName) ||
_methodsToExclude.Contains(method.Name) ||
shouldExcludeType(method) ||
isMicrosoftType(method))
{
if (!WontExcludeTypes) return null;
}
var methodString = method.ToString();
var returnName = string.Empty;
var methodSignature = methodString;
var splitIndex = methodString.IndexOf(' ');
if (splitIndex > 0)
{
returnName = methodString.Substring(0, splitIndex);
methodSignature = methodString.Substring(splitIndex + 1, methodString.Length - splitIndex - 1);
}
var typeNameFull = type.FullName;
var lineNumber = stackFrame.GetFileLineNumber();
var fileLine = string.Empty;
var filePath = stackFrame.GetFileName();
if (isTempFile(filePath))
return null;
if (!string.IsNullOrEmpty(filePath))
{
var fileName = Path.GetFileName(filePath);
fileLine = string.Format("File={0}, Line={1}", fileName, lineNumber);
methodInfo.CallingFile = fileName;
methodInfo.CallingLine = lineNumber;
methodInfo.CallingCol = stackFrame.GetFileColumnNumber();
methodInfo.CallingFileFullName = filePath;
}
//there is no valid .pdb file
if (onlyIncludeInfoWithFileLine && !File.Exists(filePath))
return null;
//couldn't extract the source file name
if (onlyIncludeInfoWithFileLine && string.IsNullOrWhiteSpace(fileLine))
return null;
var methodSignatureFull = string.Format("{0} {1}.{2}", returnName, typeNameFull, methodSignature);
methodInfo.CallingMethod = method.Name;
methodInfo.StackTrace = string.Format("{0}", methodSignatureFull);
methodInfo.AssemblyName = type.Assembly.FullName;
return methodInfo;
}
private static string StackFrameToString(StackFrame sf)
{
var sb = new StringBuilder();
MemberInfo mi = sf.GetMethod();
sb.Append(" ");
sb.Append(mi.DeclaringType.Namespace);
sb.Append(".");
sb.Append(mi.DeclaringType.Name);
sb.Append(".");
sb.Append(mi.Name);
var objParameters = sf.GetMethod().GetParameters();
sb.Append("(");
var intParam = 0;
foreach (var objParameter in objParameters)
{
intParam++;
if (intParam > 1)
{
sb.Append(", ");
}
sb.Append(objParameter.Name);
sb.Append(" As ");
sb.Append(objParameter.ParameterType.Name);
}
sb.Append(")");
sb.Append(Environment.NewLine);
sb.Append(" ");
if ((sf.GetFileName() == null) || (sf.GetFileName().Length == 0))
{
sb.Append(Path.GetFileName(ParentAssembly().CodeBase));
sb.Append(": N ");
sb.Append(string.Format("{0:#00000}", sf.GetNativeOffset()));
}
else
{
sb.Append(Path.GetFileName(sf.GetFileName()));
sb.Append(": line ");
sb.Append(string.Format("{0:#0000}", sf.GetFileLineNumber()));
sb.Append(", col ");
sb.Append(string.Format("{0:#00}", sf.GetFileColumnNumber()));
if (sf.GetILOffset() != -1)
{
sb.Append(", IL ");
sb.Append(string.Format("{0:#0000}", sf.GetILOffset()));
}
}
sb.Append(Environment.NewLine);
return sb.ToString();
}