C# StackTrace.GetFrames方法代码示例

        public void OnException(ExceptionContext context)
        {
            this._logger.LogError("MatterCenterExceptionFilter", context.Exception);
            var stackTrace = new StackTrace(context.Exception, true);
            StackFrame stackFrameInstance = null;

            if(stackTrace.GetFrames().Length>0)
            {
                for(int i=0; i< stackTrace.GetFrames().Length; i++)
                {
                    if(stackTrace.GetFrames()[i].ToString().Contains("Microsoft.Legal.Matter"))
                    {
                        stackFrameInstance = stackTrace.GetFrames()[i];
                        break;
                    }
                }
            }

            var response = new ErrorResponse()
            {
                Message = context.Exception.Message,
                StackTrace = context.Exception.ToString(),
                Description = "Error occured in the system. Please contact the administrator",
                //Exception = context.Exception.ToString(),
                LineNumber = stackFrameInstance?.GetFileLineNumber(),
                MethodName = stackFrameInstance?.GetMethod().Name,
                ClassName = stackFrameInstance?.GetMethod().DeclaringType.Name,
                ErrorCode = ((int)HttpStatusCode.InternalServerError).ToString()
            };
            context.Result = new ObjectResult(response)
            {
                StatusCode = (int)HttpStatusCode.InternalServerError,
                DeclaredType = typeof(ErrorResponse)                
            };
        }

        /// <summary>
        /// This method will generate error response that will be sent to the client
        /// </summary>
        /// <param name="ex">Exception object that occured </param>
        /// <returns></returns>
        public ErrorResponse GenerateErrorResponse(Exception ex)
        {
            var stackTrace = new StackTrace(ex, true);
            StackFrame stackFrameInstance = null;

            if (stackTrace.GetFrames().Length > 0)
            {
                for (int i = 0; i < stackTrace.GetFrames().Length; i++)
                {
                    if (stackTrace.GetFrames()[i].ToString().Contains("Microsoft.Legal.Matter"))
                    {
                        stackFrameInstance = stackTrace.GetFrames()[i];
                        break;
                    }
                }
            }
            //Create custom exception response that needs to be send to client
            var response = new ErrorResponse()
            {
                Message = ex.Message,
                StackTrace = ex.StackTrace.ToString(),
                Description = "Error occured in the system. Please contact the administrator",
                Exception = ex,
                LineNumber = stackFrameInstance?.GetFileLineNumber(),
                MethodName = stackFrameInstance?.GetMethod().Name,
                ClassName = stackFrameInstance?.GetMethod().DeclaringType.Name,
                ErrorCode = ((int)HttpStatusCode.InternalServerError).ToString(),
                IsErrror = true
            };
            return response;
        }

        public static void TraceCall()
        {
#if TRACE

            var st = new StackTrace();
            var caller_sf = st.GetFrames()[1];
            var caller_method = caller_sf.GetMethod();

            //if (caller_sf.ToString() == lastCall)
            //    return;
            //else
            //    lastCall = caller_sf.ToString();


            var caller_method_from_compiler_non_tainted = st.GetFrames().Skip(2).SkipWhile(x => x.GetMethod().DeclaringType.FullName.Contains("Microsoft.FSharp.Compiler.Tainted")).FirstOrDefault();

            // var caller_params = caller_method.GetParameters();
            Console.WriteLine("Called {0}.{1}.{2} [from {3}]", 
                                    caller_method.DeclaringType.Namespace, 
                                    caller_method.DeclaringType.Name, 
                                    caller_method.Name, 
                                    caller_method_from_compiler_non_tainted.GetMethod().Name);
#else
#endif
        }

        /// <summary>
        /// Implement OnException method of IExceptionFilter which will be invoked
        /// for all unhandled exceptions
        /// </summary>
        /// <param name="context"></param>
        public void OnException(ExceptionContext context)
        {
            this._logger.LogError("MatterCenterExceptionFilter", context.Exception);
            var stackTrace = new StackTrace(context.Exception, true);
            StackFrame stackFrameInstance = null;

            if(stackTrace.GetFrames().Length>0)
            {
                for(int i=0; i< stackTrace.GetFrames().Length; i++)
                {
                    if(stackTrace.GetFrames()[i].ToString().Contains("Microsoft.Legal.Matter"))
                    {
                        stackFrameInstance = stackTrace.GetFrames()[i];
                        break;
                    }
                }
            }
            //Create custom exception response that needs to be send to client
            var response = new ErrorResponse()
            {
                Message = context.Exception.Message,
                StackTrace = context.Exception.ToString(),
                Description = "Error occured in the system. Please contact the administrator",
                //Exception = context.Exception.ToString(),
                LineNumber = stackFrameInstance?.GetFileLineNumber(),
                MethodName = stackFrameInstance?.GetMethod().Name,
                ClassName = stackFrameInstance?.GetMethod().DeclaringType.Name,
                ErrorCode = ((int)HttpStatusCode.InternalServerError).ToString()
            };

            //Create properties that need to be added to application insights
            var properties = new Dictionary<string, string>();
            properties.Add("StackTrace", response.StackTrace);
            properties.Add("LineNumber", response.LineNumber.ToString());
            properties.Add("MethodName", response.MethodName.ToString());
            properties.Add("ClassName", response.ClassName.ToString());
            properties.Add("ErrorCode", response.ErrorCode.ToString());           

            //Create Telemetry object to add exception to the application insights
            var ai = new TelemetryClient();
            ai.InstrumentationKey = instrumentationKey;
            if(ai.IsEnabled())
            {
                //add exception to the Application Insights
                ai.TrackException(context.Exception, properties);
            }           
            
            //Send the exceptin object to the client
            context.Result = new ObjectResult(response)
            {
                StatusCode = (int)HttpStatusCode.InternalServerError,
                DeclaredType = typeof(ErrorResponse)                
            };
        }

		// 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 (StackTrace st)
		{
			if (st.FrameCount > 0)
				Assert.IsNotNull (st.GetFrame (0), "GetFrame");
			else
				Assert.IsNull (st.GetFrame (0), "GetFrame");
			if (st.FrameCount > 0)
				Assert.IsNotNull (st.GetFrames (), "GetFrames");
			else
				Assert.IsNull (st.GetFrames (), "GetFrames");
			Assert.IsNotNull (st.ToString (), "ToString");
		}

        public SentryStacktrace(Exception e)
        {
            StackTrace trace = new StackTrace(e, true);

            if (trace.GetFrames() != null)
            {
                int length = trace.GetFrames().Length;
                this.Frames = new ExceptionFrame[length];
                for (int i=0; i<length; i++) {
                    StackFrame frame = trace.GetFrame(length - i - 1);
                    this.Frames[i] = BuildExceptionFrame(frame);
                }
            }
        }

        public SentryStacktrace(Exception e)
        {
            StackTrace trace = new StackTrace(e, true);

            Frames = (trace.GetFrames() ?? new StackFrame[0]).Reverse().Select(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()
                };
            }).ToList();
        }

        /// <summary>
        /// Collects the call stack at a given moment in time.
        /// </summary>
        /// <returns>A string representing the call stack in the form Function1,Class1,FileInfo1\nFunction2,Class2,FileInfo2\n...</returns>
        protected string GetCallStack()
        {
            StackTrace stackTrace = new StackTrace(true);
            StackFrame[] stackFrames = stackTrace.GetFrames();
            string stack = string.Empty;

            foreach (StackFrame stackFrame in stackFrames)
            {
                MethodBase method = stackFrame.GetMethod();

                if (method != null && method.ReflectedType != null)
                {
                    string function = method.Name;
                    string className = method.ReflectedType.FullName;
                    string fileName = stackFrame.GetFileName();
                    string fileInfo = (fileName != null) ? string.Format(CultureInfo.InvariantCulture, "{0}:{1}", fileName.Split('\\').Last(), stackFrame.GetFileLineNumber()) : string.Empty;
                    bool isOwnCode = !(className.StartsWith("Microsoft.", StringComparison.Ordinal) || className.StartsWith("System.", StringComparison.Ordinal));

                    // This data gets stored in a custom property. The length of data stored in a custom property is limited.
                    // We save space by only sending the last part of the namespace (the class name).
                    className = className.Split('.').Last();

                    // We save even more space by only sending the "Just My Code" version of the call stack.
                    if (isOwnCode)
                    {
                        stack += string.Format(CultureInfo.InvariantCulture, "{0},{1},{2}\n", function, className, fileInfo);
                    }
                }
            }

            return stack;
        }

		private Logger Log(Level Level, object Format, params object[] Params)
		{
			if (Enabled || OnGlobalLog != null)
			{
				StackTrace stackTrace = new StackTrace();
				StackFrame StackFrame = null;
				foreach (var Frame in stackTrace.GetFrames())
				{
					if (Frame.GetMethod().DeclaringType != typeof(Logger))
					{
						StackFrame = Frame;
						break;
					}
				}

				if (Enabled)
				{
					if (OnLog != null) OnLog(Level, String.Format(Format.ToString(), Params), StackFrame);
				}

				if (OnGlobalLog != null)
				{
					OnGlobalLog(Name, Level, String.Format(Format.ToString(), Params), StackFrame);
				}
			}

			return this;
		}

        public static void BeginLog(string message)
        {
            if (LoggerData._logging.Equals(true))
            {
                string callingmethod = string.Empty;
                int managedthreadid = Thread.CurrentThread.ManagedThreadId;

                StackTrace stackTrace = new StackTrace();
                if (stackTrace != null)
                {
                    StackFrame[] stackFrames = stackTrace.GetFrames();
                    if (stackFrames != null && (stackFrames.Count() >= 1))
                    {
                        callingmethod = ((System.Type)stackFrames[1].GetMethod().ReflectedType).Name + "." + stackFrames[1].GetMethod().Name;
            //						System.Diagnostics.Debug.WriteLine(callingmethod);
                    }
                }

                LoggerData loggerdata = new LoggerData(message, System.Environment.TickCount, callingmethod);
                if (_threadtotickcountqueue.ContainsKey(managedthreadid))
                    ((Stack<LoggerData>)_threadtotickcountqueue[managedthreadid]).Push(loggerdata);
                else
                {
                    Stack<LoggerData> queue = new Stack<LoggerData>();
                    queue.Push(loggerdata);
                    _threadtotickcountqueue[managedthreadid] = queue;
                }
            }
        }

        public Boolean UsePrefix()
        {
            StackTrace stackTrace = new StackTrace();
            List<StackFrame> stackFramesNow = stackTrace.GetFrames().ToList();

            stackFramesNow.Reverse();

            Boolean foundAll = true;

            foreach (var stackFrame in stackFrames)
            {
                Boolean foundNow = false;

                foreach (var frameNow in stackFramesNow)
                {
                    string stackCompare = stackFrame.GetMethod().Module + "#" + stackFrame.GetMethod().Name;
                    string nowCompare = frameNow.GetMethod().Module + "#" + frameNow.GetMethod().Name;

                    if (stackCompare == nowCompare)
                    {
                        foundNow = true;
                        break;
                    }
                }

                foundAll = foundAll & foundNow;
            }

            return foundAll;
        }

 public static void LogError(string msg , LogType lt , Exception ex)
 {
     writeMutex.WaitOne();
     System.IO.StreamWriter file = new System.IO.StreamWriter(Env.ErrorFolderPath, true);
     file.WriteLine(lt.ToString() + ":");
     string[] lines = msg.Split('\n');
     foreach (var l in lines)
     {
         file.WriteLine(l);
     }
     file.WriteLine("_Time :"+ DateTime.Now.ToString(CultureInfo.InvariantCulture));
     if(ex != null)
     {
         var st = new StackTrace(ex, true);
         var stackFrames = st.GetFrames();
         if (stackFrames != null)
             foreach (var frame in stackFrames)
             {
                 file.WriteLine("_Frame : " + frame.ToString());
                 // Get the line number from the stack frame
                 var line = frame.GetFileLineNumber();
                 file.WriteLine("_Line : " + line.ToString());
             }
     }
     file.WriteLine("---------------------------------------------------------END----------------------------------------------------------");
     file.Close();
     writeMutex.ReleaseMutex();
 }

        public bool Perform()
        {
            Reset();

            StackTrace trace = new StackTrace(false);

            StackFrame[] frames= trace.GetFrames();
            for (int i=frames.Length-1; i>=0; i--)
            {
                StackFrame frame = frames[i];

                string typeName = frame.GetMethod().DeclaringType.FullName;

                mTrace.Append(Common.NewLine + typeName + " : " + frame.GetMethod());

                List<StackFrameBase> tests;
                if (mTests.TryGetValue("", out tests))
                {
                    if (Test(frame, trace, tests)) return true;
                }

                if (mTests.TryGetValue(typeName, out tests))
                {
                    if (Test(frame, trace, tests)) return true;
                }
            }

            return false;
        }

        private static string GetSource()
        {
            // skip 2 frames: GetSource and its caller
            var trace = new StackTrace(2);
            var frames = trace.GetFrames();

            // might not need a foreach, but doing to to be sure
            foreach (var frame in frames)
            {
                var method = frame.GetMethod();
                var type = method.DeclaringType;

                var assembly = type.Assembly;

                // only remove System?
                if (assembly.GetName().Name == "System")
                {
                    continue;
                }

                // in case there are > 2 frames
                if (type.Name == "Log")
                {
                    continue;
                }

                // that sounds just about nice
                return string.Format("{0}::{1}", type.Name, method.Name);
            }

            return "";
        }

 public static void ER(Exception e, params string[] extras)
 {
     StackTrace st = new StackTrace();
     StackFrame[] frames = st.GetFrames();
     string methodName = "UnknownMethod";
     for(int i=0;i< frames.Length;i++)
     {
         if (frames[i].GetMethod().Name == System.Reflection.MethodInfo.GetCurrentMethod().Name)
         {
             if (i + 1 < frames.Length)
             {
                 methodName = frames[i + 1].GetMethod().Name;
                 break;
             }
         }
     }
     Console.WriteLine(String.Format("{1}[{4}:{5}][ERROR({2})]{0}:{3}", methodName, tab, Thread.CurrentThread.ManagedThreadId, e.Message, DateTime.Now.ToShortDateString(), DateTime.Now.ToShortTimeString()));
     Console.WriteLine("==========StackTrace==========");
     if (e.StackTrace != null)
         Console.WriteLine(e.StackTrace.ToString());
     else
         Console.WriteLine(st.ToString());
     Console.WriteLine("=============END==============");
     foreach (string s in extras)
         Console.WriteLine(s);
 }