private static bool FormatFileName(bool displayFilenames, StackFrame frame, StringBuilder stringBuilder) { if (displayFilenames && frame.GetILOffset() != -1) { string text = null; try { text = frame.GetFileName(); } catch (NotSupportedException) { displayFilenames = false; } catch (SecurityException) { displayFilenames = false; } if (text != null) { stringBuilder.Append(' '); stringBuilder.AppendFormat(CultureInfo.InvariantCulture, LineFormat, text, frame.GetFileLineNumber()); } } return(displayFilenames); }
/// <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(); }
private StackFrameInfo(StackFrame frame) { SetStackMeta(frame); if (frame.GetILOffset() == -1) { return; } string filename = null; try { filename = frame.GetFileName(); if (filename != null) { LineNumber = frame.GetFileLineNumber(); } } catch (SecurityException) { } FileName = filename; }
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 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 CallSite(StackFrame frame) { Line = frame.GetFileLineNumber(); File = frame.GetFileName(); ILOffset = frame.GetILOffset(); var method = frame.GetMethod(); if (method != null) Method = new MethodInfo(method); }
// 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 FormatLocation(StackFrame frame) { StringBuilder location = new StringBuilder(); location.Append(frame.GetMethod().DeclaringType.ToString()); location.Append("=>"); location.Append(frame.GetMethod().ToString()); location.Append(" ["); location.Append(frame.GetILOffset()); location.Append(":"); location.Append(frame.GetNativeOffset()); location.Append("]"); return location.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 void TraceCallers(int Depth) { if (_switch.Enabled) { System.Diagnostics.StackTrace st = new System.Diagnostics.StackTrace(1); if (Depth < 0) Depth = st.FrameCount; Indent(); for (int i=0; i < st.FrameCount && i < Depth; i++) { System.Diagnostics.StackFrame sf = st.GetFrame(i); Trace(sf.GetMethod()+"+"+sf.GetILOffset().ToString(System.Globalization.CultureInfo.InvariantCulture)); } Unindent(); } }
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 void TraceCallers(int Depth) { #if DEBUG if (_switch.Enabled) { System.Diagnostics.StackTrace st = new System.Diagnostics.StackTrace(1); if (Depth < 0) { Depth = st.FrameCount; } Indent(); for (int i = 0; i < st.FrameCount && i < Depth; i++) { System.Diagnostics.StackFrame sf = st.GetFrame(i); Trace(sf.GetMethod() + "+" + sf.GetILOffset().ToString()); } Unindent(); } #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> /// Builds a readable representation of the stack trace, specifying /// the format for backwards compatibility. /// </summary> internal string ToString(TraceFormat traceFormat) { string word_At = SR.Word_At; string inFileLineNum = SR.StackTrace_InFileLineNumber; bool fFirstFrame = true; StringBuilder sb = new StringBuilder(255); for (int iFrameIndex = 0; iFrameIndex < _numOfFrames; iFrameIndex++) { StackFrame sf = GetFrame(iFrameIndex); MethodBase mb = sf.GetMethod(); if (mb != null && (ShowInStackTrace(mb) || (iFrameIndex == _numOfFrames - 1))) // Don't filter last frame { // We want a newline at the end of every line except for the last if (fFirstFrame) { fFirstFrame = false; } else { sb.Append(Environment.NewLine); } sb.AppendFormat(CultureInfo.InvariantCulture, " {0} ", word_At); bool isAsync = false; Type declaringType = mb.DeclaringType; string methodName = mb.Name; bool methodChanged = false; if (declaringType != null && declaringType.IsDefined(typeof(CompilerGeneratedAttribute), inherit: false)) { isAsync = typeof(IAsyncStateMachine).IsAssignableFrom(declaringType); if (isAsync || typeof(IEnumerator).IsAssignableFrom(declaringType)) { methodChanged = TryResolveStateMachineMethod(ref mb, out declaringType); } } // if there is a type (non global method) print it // ResolveStateMachineMethod may have set declaringType to null if (declaringType != null) { // Append t.FullName, replacing '+' with '.' string fullName = declaringType.FullName; for (int i = 0; i < fullName.Length; i++) { char ch = fullName[i]; sb.Append(ch == '+' ? '.' : ch); } sb.Append('.'); } sb.Append(mb.Name); // deal with the generic portion of the method if (mb is MethodInfo mi && mi.IsGenericMethod) { Type[] typars = mi.GetGenericArguments(); sb.Append('['); int k = 0; bool fFirstTyParam = true; while (k < typars.Length) { if (fFirstTyParam == false) { sb.Append(','); } else { fFirstTyParam = false; } sb.Append(typars[k].Name); k++; } sb.Append(']'); } ParameterInfo[] pi = null; try { pi = mb.GetParameters(); } catch { // The parameter info cannot be loaded, so we don't // append the parameter list. } if (pi != null) { // arguments printing sb.Append('('); bool fFirstParam = true; for (int j = 0; j < pi.Length; j++) { if (fFirstParam == false) { sb.Append(", "); } else { fFirstParam = false; } string typeName = "<UnknownType>"; if (pi[j].ParameterType != null) { typeName = pi[j].ParameterType.Name; } sb.Append(typeName); sb.Append(' '); sb.Append(pi[j].Name); } sb.Append(')'); } if (methodChanged) { // Append original method name e.g. +MoveNext() sb.Append('+'); sb.Append(methodName); sb.Append('(').Append(')'); } // source location printing if (sf.GetILOffset() != -1) { // If we don't have a PDB or PDB-reading is disabled for the module, // then the file name will be null. string fileName = sf.GetFileName(); if (fileName != null) { // tack on " in c:\tmp\MyFile.cs:line 5" sb.Append(' '); sb.AppendFormat(CultureInfo.InvariantCulture, inFileLineNum, fileName, sf.GetFileLineNumber()); } } if (sf.GetIsLastFrameFromForeignExceptionStackTrace() && !isAsync) // Skip EDI boundary for async { sb.Append(Environment.NewLine); sb.Append(SR.Exception_EndStackTraceFromPreviousThrow); } } } if (traceFormat == TraceFormat.TrailingNewLine) { sb.Append(Environment.NewLine); } return(sb.ToString()); }
internal string ToString(TraceFormat traceFormat) { string resourceString = "at"; string format = "in {0}:line {1}"; if (traceFormat != TraceFormat.NoResourceLookup) { resourceString = Environment.GetResourceString("Word_At"); format = Environment.GetResourceString("StackTrace_InFileLineNumber"); } bool flag = true; StringBuilder builder = new StringBuilder(0xff); for (int i = 0; i < this.m_iNumOfFrames; i++) { StackFrame frame = this.GetFrame(i); MethodBase method = frame.GetMethod(); if (method != null) { if (flag) { flag = false; } else { builder.Append(Environment.NewLine); } builder.AppendFormat(CultureInfo.InvariantCulture, " {0} ", new object[] { resourceString }); Type declaringType = method.DeclaringType; if (declaringType != null) { builder.Append(declaringType.FullName.Replace('+', '.')); builder.Append("."); } builder.Append(method.Name); if ((method is MethodInfo) && ((MethodInfo)method).IsGenericMethod) { Type[] genericArguments = ((MethodInfo)method).GetGenericArguments(); builder.Append("["); int index = 0; bool flag2 = true; while (index < genericArguments.Length) { if (!flag2) { builder.Append(","); } else { flag2 = false; } builder.Append(genericArguments[index].Name); index++; } builder.Append("]"); } builder.Append("("); ParameterInfo[] parameters = method.GetParameters(); bool flag3 = true; for (int j = 0; j < parameters.Length; j++) { if (!flag3) { builder.Append(", "); } else { flag3 = false; } string name = "<UnknownType>"; if (parameters[j].ParameterType != null) { name = parameters[j].ParameterType.Name; } builder.Append(name + " " + parameters[j].Name); } builder.Append(")"); if (frame.GetILOffset() != -1) { string fileName = null; try { fileName = frame.GetFileName(); } catch (SecurityException) { } if (fileName != null) { builder.Append(' '); builder.AppendFormat(CultureInfo.InvariantCulture, format, new object[] { fileName, frame.GetFileLineNumber() }); } } } } if (traceFormat == TraceFormat.TrailingNewLine) { builder.Append(Environment.NewLine); } return(builder.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(); }
private void CalculateStatistics(object sender, FirstChanceExceptionEventArgs firstChanceExceptionArgs) { // this is thread local variable. No need to lock if (executionSyncObject == LOCKED) { return; } try { Exception exception; string exceptionType; System.Diagnostics.StackFrame exceptionStackFrame; string problemId; string methodName = "UnknownMethod"; int methodOffset = System.Diagnostics.StackFrame.OFFSET_UNKNOWN; bool getOperationName = false; executionSyncObject = LOCKED; if (this.MovingAverageTimeout < DateTime.UtcNow.Ticks) { lock (this.movingAverageLockObject) { if (this.MovingAverageTimeout < DateTime.UtcNow.Ticks) { if (this.MovingAverageTimeout + TicksMovingAverage < DateTime.UtcNow.Ticks) { this.currentMovingAverage = 0; } else { this.currentMovingAverage = (this.currentMovingAverage * CurrentWeight) + (((double)this.newProcessed) * NewWeight); } this.newThreshold = (long)((this.TargetMovingAverage - (this.currentMovingAverage * CurrentWeight)) / NewWeight); this.newProcessed = 0; this.MovingAverageTimeout = DateTime.UtcNow.Ticks + TicksMovingAverage; } } } exception = firstChanceExceptionArgs?.Exception; if (exception == null) { WindowsServerEventSource.Log.FirstChanceExceptionCallbackExeptionIsNull(); return; } if (WasExceptionTracked(exception) == true) { return; } exceptionType = exception.GetType().FullName; exceptionStackFrame = new System.Diagnostics.StackFrame(1); if (exceptionStackFrame != null) { MethodBase methodBase = exceptionStackFrame.GetMethod(); if (methodBase != null) { methodName = (methodBase.DeclaringType?.FullName ?? "Global") + "." + methodBase.Name; methodOffset = exceptionStackFrame.GetILOffset(); } } if (methodOffset == System.Diagnostics.StackFrame.OFFSET_UNKNOWN) { problemId = exceptionType + " at " + methodName; } else { problemId = exceptionType + " at " + methodName + ":" + methodOffset.ToString(CultureInfo.InvariantCulture); } if (this.newProcessed < this.newThreshold) { Interlocked.Increment(ref this.newProcessed); getOperationName = true; } this.TrackStatistics(getOperationName, problemId, exception); } catch (Exception exc) { try { WindowsServerEventSource.Log.FirstChanceExceptionCallbackException(exc.ToInvariantString()); } catch (Exception) { // this is absolutely critical to not throw out of this method // Otherwise it will affect the customer application behavior significantly } } finally { executionSyncObject = UNLOCKED; } }
// Builds a readable representation of the stack trace, specifying // the format for backwards compatibility. internal string ToString(TraceFormat traceFormat) { bool displayFilenames = true; // we'll try, but demand may fail string word_At = "at"; string inFileLineNum = "in {0}:line {1}"; if (traceFormat != TraceFormat.NoResourceLookup) { word_At = SR.Word_At; inFileLineNum = SR.StackTrace_InFileLineNumber; } bool fFirstFrame = true; StringBuilder sb = new StringBuilder(255); for (int iFrameIndex = 0; iFrameIndex < m_iNumOfFrames; iFrameIndex++) { StackFrame sf = GetFrame(iFrameIndex); MethodBase mb = sf.GetMethod(); if (mb != null && (ShowInStackTrace(mb) || (iFrameIndex == m_iNumOfFrames - 1))) // Don't filter last frame { // We want a newline at the end of every line except for the last if (fFirstFrame) { fFirstFrame = false; } else { sb.Append(Environment.NewLine); } sb.AppendFormat(CultureInfo.InvariantCulture, " {0} ", word_At); bool isAsync = false; Type declaringType = mb.DeclaringType; string methodName = mb.Name; bool methodChanged = false; if (declaringType != null && declaringType.IsDefined(typeof(CompilerGeneratedAttribute))) { isAsync = typeof(IAsyncStateMachine).IsAssignableFrom(declaringType); if (isAsync || typeof(IEnumerator).IsAssignableFrom(declaringType)) { methodChanged = TryResolveStateMachineMethod(ref mb, out declaringType); } } // if there is a type (non global method) print it // ResolveStateMachineMethod may have set declaringType to null if (declaringType != null) { // Append t.FullName, replacing '+' with '.' string fullName = declaringType.FullName; for (int i = 0; i < fullName.Length; i++) { char ch = fullName[i]; sb.Append(ch == '+' ? '.' : ch); } sb.Append('.'); } sb.Append(mb.Name); // deal with the generic portion of the method if (mb is MethodInfo && ((MethodInfo)mb).IsGenericMethod) { Type[] typars = ((MethodInfo)mb).GetGenericArguments(); sb.Append('['); int k = 0; bool fFirstTyParam = true; while (k < typars.Length) { if (fFirstTyParam == false) { sb.Append(','); } else { fFirstTyParam = false; } sb.Append(typars[k].Name); k++; } sb.Append(']'); } ParameterInfo[] pi = null; try { pi = mb.GetParameters(); } catch { // The parameter info cannot be loaded, so we don't // append the parameter list. } if (pi != null) { // arguments printing sb.Append('('); bool fFirstParam = true; for (int j = 0; j < pi.Length; j++) { if (fFirstParam == false) { sb.Append(", "); } else { fFirstParam = false; } string typeName = "<UnknownType>"; if (pi[j].ParameterType != null) { typeName = pi[j].ParameterType.Name; } sb.Append(typeName); sb.Append(' '); sb.Append(pi[j].Name); } sb.Append(')'); } if (methodChanged) { // Append original method name e.g. +MoveNext() sb.Append("+"); sb.Append(methodName); sb.Append("()"); } // source location printing if (displayFilenames && (sf.GetILOffset() != -1)) { // If we don't have a PDB or PDB-reading is disabled for the module, // then the file name will be null. string fileName = null; // Getting the filename from a StackFrame is a privileged operation - we won't want // to disclose full path names to arbitrarily untrusted code. Rather than just omit // this we could probably trim to just the filename so it's still mostly usefull. try { fileName = sf.GetFileName(); } catch (SecurityException) { // If the demand for displaying filenames fails, then it won't // succeed later in the loop. Avoid repeated exceptions by not trying again. displayFilenames = false; } if (fileName != null) { // tack on " in c:\tmp\MyFile.cs:line 5" sb.Append(' '); sb.AppendFormat(CultureInfo.InvariantCulture, inFileLineNum, fileName, sf.GetFileLineNumber()); } } if (sf.GetIsLastFrameFromForeignExceptionStackTrace() && !isAsync) // Skip EDI boundary for async { sb.Append(Environment.NewLine); sb.Append(SR.Exception_EndStackTraceFromPreviousThrow); } } } if (traceFormat == TraceFormat.TrailingNewLine) { sb.Append(Environment.NewLine); } return(sb.ToString()); }
public static bool HasILOffset(this StackFrame stackFrame) { return(stackFrame.GetILOffset() != StackFrame.OFFSET_UNKNOWN); }
//-- //-- 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(); }
// Token: 0x0600325C RID: 12892 RVA: 0x000C1298 File Offset: 0x000BF498 internal string ToString(StackTrace.TraceFormat traceFormat) { bool flag = true; string arg = "at"; string format = "in {0}:line {1}"; if (traceFormat != StackTrace.TraceFormat.NoResourceLookup) { arg = Environment.GetResourceString("Word_At"); format = Environment.GetResourceString("StackTrace_InFileLineNumber"); } bool flag2 = true; StringBuilder stringBuilder = new StringBuilder(255); for (int i = 0; i < this.m_iNumOfFrames; i++) { StackFrame frame = this.GetFrame(i); MethodBase method = frame.GetMethod(); if (method != null) { if (flag2) { flag2 = false; } else { stringBuilder.Append(Environment.NewLine); } stringBuilder.AppendFormat(CultureInfo.InvariantCulture, " {0} ", arg); Type declaringType = method.DeclaringType; if (declaringType != null) { stringBuilder.Append(declaringType.FullName.Replace('+', '.')); stringBuilder.Append("."); } stringBuilder.Append(method.Name); if (method is MethodInfo && ((MethodInfo)method).IsGenericMethod) { Type[] genericArguments = ((MethodInfo)method).GetGenericArguments(); stringBuilder.Append("["); int j = 0; bool flag3 = true; while (j < genericArguments.Length) { if (!flag3) { stringBuilder.Append(","); } else { flag3 = false; } stringBuilder.Append(genericArguments[j].Name); j++; } stringBuilder.Append("]"); } stringBuilder.Append("("); ParameterInfo[] parameters = method.GetParameters(); bool flag4 = true; for (int k = 0; k < parameters.Length; k++) { if (!flag4) { stringBuilder.Append(", "); } else { flag4 = false; } string str = "<UnknownType>"; if (parameters[k].ParameterType != null) { str = parameters[k].ParameterType.Name; } stringBuilder.Append(str + " " + parameters[k].Name); } stringBuilder.Append(")"); if (flag && frame.GetILOffset() != -1) { string text = null; try { text = frame.GetFileName(); } catch (NotSupportedException) { flag = false; } catch (SecurityException) { flag = false; } if (text != null) { stringBuilder.Append(' '); stringBuilder.AppendFormat(CultureInfo.InvariantCulture, format, text, frame.GetFileLineNumber()); } } if (frame.GetIsLastFrameFromForeignExceptionStackTrace()) { stringBuilder.Append(Environment.NewLine); stringBuilder.Append(Environment.GetResourceString("Exception_EndStackTraceFromPreviousThrow")); } } } if (traceFormat == StackTrace.TraceFormat.TrailingNewLine) { stringBuilder.Append(Environment.NewLine); } return(stringBuilder.ToString()); }
private static string GetCurLine(StackFrame sf) { if (sf.GetILOffset() != -1) { string s = null; try { s = sf.GetFileName(); } catch (SecurityException) { } if (s != null) { return string.Format(" in {0}:line {1}", s, sf.GetFileLineNumber()); } } return ""; }
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(); }
/// <summary> /// Gets the offset from the start of the Microsoft intermediate language (MSIL) /// code for the method that is executing. This offset might be an approximation /// depending on whether or not the just-in-time (JIT) compiler is generating debugging /// code. The generation of this debugging information is controlled by the System.Diagnostics.DebuggableAttribute. /// </summary> /// <returns>The offset from the start of the MSIL code for the method that is executing.</returns> public override int GetILOffset() => StackFrame.GetILOffset();
private static AirbrakeTraceLine TraceLineForFrame(StackFrame frame) { var method = frame.GetMethod(); var lineNumber = frame.GetFileLineNumber(); if (lineNumber == 0) lineNumber = frame.GetILOffset(); var fileName = frame.GetFileName(); if (string.IsNullOrEmpty(fileName)) fileName = method.ReflectedType != null ? method.ReflectedType.FullName : "(unknown)"; return new AirbrakeTraceLine(fileName, lineNumber, method.Name); }
/// <summary> /// Gets the offset from the start of the Microsoft intermediate language (MSIL) /// code for the method that is executing. This offset might be an approximation /// depending on whether or not the just-in-time (JIT) compiler is generating debugging /// code. The generation of this debugging information is controlled by the System.Diagnostics.DebuggableAttribute. /// </summary> /// <returns>The offset from the start of the MSIL code for the method that is executing.</returns> public override int GetILOffset() { return(StackFrame.GetILOffset()); }
[System.Security.SecurityCritical] // auto-generated #endif internal String ToString(TraceFormat traceFormat) { bool displayFilenames = true; // we'll try, but demand may fail String word_At = "at"; String inFileLineNum = "in {0}:line {1}"; if (traceFormat != TraceFormat.NoResourceLookup) { word_At = Environment.GetResourceString("Word_At"); inFileLineNum = Environment.GetResourceString("StackTrace_InFileLineNumber"); } bool fFirstFrame = true; StringBuilder sb = new StringBuilder(255); for (int iFrameIndex = 0; iFrameIndex < m_iNumOfFrames; iFrameIndex++) { StackFrame sf = GetFrame(iFrameIndex); MethodBase mb = sf.GetMethod(); if (mb != null) { // We want a newline at the end of every line except for the last if (fFirstFrame) { fFirstFrame = false; } else { sb.Append(Environment.NewLine); } sb.AppendFormat(CultureInfo.InvariantCulture, " {0} ", word_At); Type t = mb.DeclaringType; // if there is a type (non global method) print it if (t != null) { // Append t.FullName, replacing '+' with '.' string fullName = t.FullName; for (int i = 0; i < fullName.Length; i++) { char ch = fullName[i]; sb.Append(ch == '+' ? '.' : ch); } sb.Append('.'); } sb.Append(mb.Name); // deal with the generic portion of the method if (mb is MethodInfo && ((MethodInfo)mb).IsGenericMethod) { Type[] typars = ((MethodInfo)mb).GetGenericArguments(); sb.Append('['); int k = 0; bool fFirstTyParam = true; while (k < typars.Length) { if (fFirstTyParam == false) { sb.Append(','); } else { fFirstTyParam = false; } sb.Append(typars[k].Name); k++; } sb.Append(']'); } ParameterInfo[] pi = null; #if FEATURE_CORECLR try { #endif pi = mb.GetParameters(); #if FEATURE_CORECLR } catch { // The parameter info cannot be loaded, so we don't // append the parameter list. } #endif if (pi != null) { // arguments printing sb.Append('('); bool fFirstParam = true; for (int j = 0; j < pi.Length; j++) { if (fFirstParam == false) { sb.Append(", "); } else { fFirstParam = false; } String typeName = "<UnknownType>"; if (pi[j].ParameterType != null) { typeName = pi[j].ParameterType.Name; } sb.Append(typeName); sb.Append(' '); sb.Append(pi[j].Name); } sb.Append(')'); } // source location printing if (displayFilenames && (sf.GetILOffset() != -1)) { // If we don't have a PDB or PDB-reading is disabled for the module, // then the file name will be null. String fileName = null; // Getting the filename from a StackFrame is a privileged operation - we won't want // to disclose full path names to arbitrarily untrusted code. Rather than just omit // this we could probably trim to just the filename so it's still mostly usefull. try { fileName = sf.GetFileName(); } catch (SecurityException) { // If the demand for displaying filenames fails, then it won't // succeed later in the loop. Avoid repeated exceptions by not trying again. displayFilenames = false; } if (fileName != null) { // tack on " in c:\tmp\MyFile.cs:line 5" sb.Append(' '); sb.AppendFormat(CultureInfo.InvariantCulture, inFileLineNum, fileName, sf.GetFileLineNumber()); } } #if FEATURE_EXCEPTIONDISPATCHINFO if (sf.GetIsLastFrameFromForeignExceptionStackTrace()) { sb.Append(Environment.NewLine); sb.Append(Environment.GetResourceString("Exception_EndStackTraceFromPreviousThrow")); } #endif // FEATURE_EXCEPTIONDISPATCHINFO } } if (traceFormat == TraceFormat.TrailingNewLine) { sb.Append(Environment.NewLine); } return(sb.ToString()); }
bool AddFrames(StringBuilder sb) { bool printOffset; string debugInfo, indentation; string unknown = Locale.GetText("<unknown method>"); indentation = " "; debugInfo = Locale.GetText(" in {0}:{1} "); var newline = String.Format("{0}{1}{2} ", Environment.NewLine, indentation, Locale.GetText("at")); int i; for (i = 0; i < FrameCount; i++) { StackFrame frame = GetFrame(i); if (i == 0) { sb.AppendFormat("{0}{1} ", indentation, Locale.GetText("at")); } else { sb.Append(newline); } if (frame.GetMethod() == null) { string internal_name = frame.GetInternalMethodName(); if (internal_name != null) { sb.Append(internal_name); } else { sb.AppendFormat("<0x{0:x5} + 0x{1:x5}> {2}", frame.GetMethodAddress(), frame.GetNativeOffset(), unknown); } } else { GetFullNameForStackTrace(sb, frame.GetMethod()); if (frame.GetILOffset() == -1) { sb.AppendFormat(" <0x{0:x5} + 0x{1:x5}>", frame.GetMethodAddress(), frame.GetNativeOffset()); if (frame.GetMethodIndex() != 0xffffff) { sb.AppendFormat(" {0}", frame.GetMethodIndex()); } } else { sb.AppendFormat(" [0x{0:x5}]", frame.GetILOffset()); } sb.AppendFormat(debugInfo, frame.GetSecureFileName(), frame.GetFileLineNumber()); } } return(i != 0); }
private static string StackFrameToString(StackFrame sf) { int intParam = 0; var sb = new StringBuilder(); MemberInfo mi = sf.GetMethod(); { //-- build method name sb.Append(" "); sb.Append(mi.DeclaringType.Namespace); sb.Append("."); sb.Append(mi.DeclaringType.Name); sb.Append("."); sb.Append(mi.Name); //-- build method params ParameterInfo[] objParameters = sf.GetMethod().GetParameters(); sb.Append("("); intParam = 0; foreach (var objParameter in objParameters) { intParam += 1; if (intParam > 1) sb.Append(", "); sb.Append(objParameter.Name); sb.Append(" As "); sb.Append(objParameter.ParameterType.Name); } sb.Append(")"); sb.Append(Environment.NewLine); //-- if source code is available, append location info sb.Append(" "); if (string.IsNullOrEmpty(sf.GetFileName())) { sb.Append(Path.GetFileName(GetParentAssembly().CodeBase)); //-- native code offset is always available 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 IL is available, append IL location info if (sf.GetILOffset() != StackFrame.OFFSET_UNKNOWN) { sb.Append(", IL "); sb.Append(string.Format("{0:#0000}", sf.GetILOffset())); } } sb.Append(Environment.NewLine); } return sb.ToString(); }
private bool TryGetStackFrameInfo(StackFrame/*!*/ frame, out string/*!*/ methodName, out string/*!*/ fileName, out int line) { MethodBase method = frame.GetMethod(); methodName = method.Name; fileName = (_hasFileAccessPermission) ? frame.GetFileName() : null; var sourceLine = line = frame.GetFileLineNumber(); if (TryParseRubyMethodName(ref methodName, ref fileName, ref line)) { if (sourceLine == 0) { RubyMethodDebugInfo debugInfo; if (RubyMethodDebugInfo.TryGet(method, out debugInfo)) { var ilOffset = frame.GetILOffset(); if (ilOffset >= 0) { var mappedLine = debugInfo.Map(ilOffset); if (mappedLine != 0) { line = mappedLine; } } } } return true; } else if (method.IsDefined(typeof(RubyStackTraceHiddenAttribute), false)) { return false; } else { object[] attrs = method.GetCustomAttributes(typeof(RubyMethodAttribute), false); if (attrs.Length > 0) { // Ruby library method: // TODO: aliases methodName = ((RubyMethodAttribute)attrs[0]).Name; if (!_exceptionDetail) { fileName = null; line = NextFrameLine; } return true; } else if (_exceptionDetail || IsVisibleClrFrame(method)) { // Visible CLR method: if (String.IsNullOrEmpty(fileName)) { if (method.DeclaringType != null) { fileName = (_hasFileAccessPermission) ? method.DeclaringType.Assembly.GetName().Name : null; line = 0; } } return true; } else { // Invisible CLR method: return false; } } }
internal string ToString(StackTrace.TraceFormat traceFormat) { bool flag1 = true; string str1 = "at"; string format = "in {0}:line {1}"; if (traceFormat != StackTrace.TraceFormat.NoResourceLookup) { str1 = Environment.GetResourceString("Word_At"); format = Environment.GetResourceString("StackTrace_InFileLineNumber"); } bool flag2 = true; StringBuilder stringBuilder = new StringBuilder((int)byte.MaxValue); for (int index1 = 0; index1 < this.m_iNumOfFrames; ++index1) { StackFrame frame = this.GetFrame(index1); MethodBase method = frame.GetMethod(); if (method != (MethodBase)null) { if (flag2) { flag2 = false; } else { stringBuilder.Append(Environment.NewLine); } stringBuilder.AppendFormat((IFormatProvider)CultureInfo.InvariantCulture, " {0} ", (object)str1); Type declaringType = method.DeclaringType; if (declaringType != (Type)null) { stringBuilder.Append(declaringType.FullName.Replace('+', '.')); stringBuilder.Append("."); } stringBuilder.Append(method.Name); if (method is MethodInfo && method.IsGenericMethod) { Type[] genericArguments = method.GetGenericArguments(); stringBuilder.Append("["); int index2 = 0; bool flag3 = true; for (; index2 < genericArguments.Length; ++index2) { if (!flag3) { stringBuilder.Append(","); } else { flag3 = false; } stringBuilder.Append(genericArguments[index2].Name); } stringBuilder.Append("]"); } stringBuilder.Append("("); ParameterInfo[] parameters = method.GetParameters(); bool flag4 = true; for (int index2 = 0; index2 < parameters.Length; ++index2) { if (!flag4) { stringBuilder.Append(", "); } else { flag4 = false; } string str2 = "<UnknownType>"; if (parameters[index2].ParameterType != (Type)null) { str2 = parameters[index2].ParameterType.Name; } stringBuilder.Append(str2 + " " + parameters[index2].Name); } stringBuilder.Append(")"); if (flag1 && frame.GetILOffset() != -1) { string str2 = (string)null; try { str2 = frame.GetFileName(); } catch (NotSupportedException ex) { flag1 = false; } catch (SecurityException ex) { flag1 = false; } if (str2 != null) { stringBuilder.Append(' '); stringBuilder.AppendFormat((IFormatProvider)CultureInfo.InvariantCulture, format, (object)str2, (object)frame.GetFileLineNumber()); } } if (frame.GetIsLastFrameFromForeignExceptionStackTrace()) { stringBuilder.Append(Environment.NewLine); stringBuilder.Append(Environment.GetResourceString("Exception_EndStackTraceFromPreviousThrow")); } } } if (traceFormat == StackTrace.TraceFormat.TrailingNewLine) { stringBuilder.Append(Environment.NewLine); } return(stringBuilder.ToString()); }
bool AddFrames(StringBuilder sb) { bool any_frame = false; for (int i = 0; i < FrameCount; i++) { StackFrame frame = GetFrame(i); if (frame.GetMethod() == null) { if (any_frame) { sb.Append(Environment.NewLine); } sb.Append(prefix); string internal_name = frame.GetInternalMethodName(); if (internal_name != null) { sb.Append(internal_name); } else { sb.AppendFormat("<0x{0:x5} + 0x{1:x5}> <unknown method>", frame.GetMethodAddress(), frame.GetNativeOffset()); } } else { GetFullNameForStackTrace(sb, frame.GetMethod(), any_frame, out var skipped); if (skipped) { continue; } if (frame.GetILOffset() == -1) { sb.AppendFormat(" <0x{0:x5} + 0x{1:x5}>", frame.GetMethodAddress(), frame.GetNativeOffset()); if (frame.GetMethodIndex() != 0xffffff) { sb.AppendFormat(" {0}", frame.GetMethodIndex()); } } else { sb.AppendFormat(" [0x{0:x5}]", frame.GetILOffset()); } var filename = frame.GetSecureFileName(); if (filename[0] == '<') { var mvid = frame.GetMethod().Module.ModuleVersionId.ToString("N"); var aotid = GetAotId(); if (frame.GetILOffset() != -1 || aotid == null) { filename = string.Format("<{0}>", mvid); } else { filename = string.Format("<{0}#{1}>", mvid, aotid); } } sb.AppendFormat(" in {0}:{1} ", filename, frame.GetFileLineNumber()); } any_frame = true; } return(any_frame); }
// Builds a readable representation of the stack trace, specifying // the format for backwards compatibility. internal String ToString(TraceFormat traceFormat) { String word_At = "at"; String inFileLineNum = "in {0}:line {1}"; if (traceFormat != TraceFormat.NoResourceLookup) { word_At = Environment.GetResourceString("Word_At"); inFileLineNum = Environment.GetResourceString("StackTrace_InFileLineNumber"); } bool fFirstFrame = true; StringBuilder sb = new StringBuilder(255); for (int iFrameIndex = 0; iFrameIndex < m_iNumOfFrames; iFrameIndex++) { StackFrame sf = GetFrame(iFrameIndex); MethodBase mb = sf.GetMethod(); if (mb != null) { // We want a newline at the end of every line except for the last if (fFirstFrame) { fFirstFrame = false; } else { sb.Append(Environment.NewLine); } sb.AppendFormat(CultureInfo.InvariantCulture, " {0} ", word_At); Type t = mb.DeclaringType; // if there is a type (non global method) print it if (t != null) { sb.Append(t.FullName.Replace('+', '.')); sb.Append("."); } sb.Append(mb.Name); // deal with the generic portion of the method if (mb is MethodInfo && ((MethodInfo)mb).IsGenericMethod) { Type[] typars = ((MethodInfo)mb).GetGenericArguments(); sb.Append("["); int k = 0; bool fFirstTyParam = true; while (k < typars.Length) { if (fFirstTyParam == false) { sb.Append(","); } else { fFirstTyParam = false; } sb.Append(typars[k].Name); k++; } sb.Append("]"); } // arguments printing sb.Append("("); ParameterInfo[] pi = mb.GetParameters(); bool fFirstParam = true; for (int j = 0; j < pi.Length; j++) { if (fFirstParam == false) { sb.Append(", "); } else { fFirstParam = false; } String typeName = "<UnknownType>"; if (pi[j].ParameterType != null) { typeName = pi[j].ParameterType.Name; } sb.Append(typeName + " " + pi[j].Name); } sb.Append(")"); // source location printing if (sf.GetILOffset() != -1) { // It's possible we have a debug version of an executable but no PDB. In // this case, the file name will be null. String fileName = null; try { fileName = sf.GetFileName(); } catch (SecurityException) { } if (fileName != null) { // tack on " in c:\tmp\MyFile.cs:line 5" sb.Append(' '); sb.AppendFormat(CultureInfo.InvariantCulture, inFileLineNum, fileName, sf.GetFileLineNumber()); } } } } if (traceFormat == TraceFormat.TrailingNewLine) { sb.Append(Environment.NewLine); } return(sb.ToString()); }
/// <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 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(); }
private static string BuildLineForStackFrame(StackFrame frame) { var builder = new StringBuilder("<pre>"); var method = frame.GetMethod(); // Special case: no method available if (method == null) { return null; } // First, write the type name var type = method.DeclaringType; if (type != null) { // Special-case ExceptionDispatchInfo.Throw() if (type == typeof(ExceptionDispatchInfo) && method.Name == "Throw") { return @"<pre><span class=""faded"">--- exception rethrown ---</span></pre>"; } string prefix, friendlyName; SplitTypeIntoPrefixAndFriendlyName(type, out prefix, out friendlyName); builder.AppendFormat(CultureInfo.InvariantCulture, @"<span class=""faded"">at {0}</span>", HtmlEncodeAndReplaceLineBreaks(prefix)); builder.Append(HtmlEncodeAndReplaceLineBreaks(friendlyName)); } // Next, write the method signature builder.Append(HtmlEncodeAndReplaceLineBreaks("." + method.Name)); // Is this method generic? if (method.IsGenericMethod) { builder.Append(HtmlEncodeAndReplaceLineBreaks(BuildMethodGenericParametersUnescaped(method))); } // Build method parameters builder.AppendFormat(CultureInfo.InvariantCulture, @"<span class=""faded"">{0}</span>", HtmlEncodeAndReplaceLineBreaks(BuildMethodParametersUnescaped(method))); // Do we have source information for this frame? if (frame.GetILOffset() != -1) { var filename = frame.GetFileName(); if (!string.IsNullOrEmpty(filename)) { builder.AppendFormat(CultureInfo.InvariantCulture, " in {0}:line {1:D}", HtmlEncodeAndReplaceLineBreaks(filename), frame.GetFileLineNumber()); } } // Finish builder.Append("</pre>"); return builder.ToString(); }
private string SourceCodeInformation(StackFrame frame) { if (String.IsNullOrEmpty(frame.GetFileName())) return Path.GetFileName(_assemblyInfo.CodeBase) + ": N " + frame.GetNativeOffset(); return Path.GetFileName(frame.GetFileName()) + ": line " + frame.GetFileLineNumber() + ", col " + frame.GetFileColumnNumber() + ", IL " + frame.GetILOffset(); }