//Can only be called inside a service
        public static void PromoteException(Exception error,MessageVersion version,ref Message fault)
        {
            StackFrame frame = new StackFrame(1);

             Type serviceType = frame.GetMethod().ReflectedType;
             PromoteException(serviceType,error,version,ref fault);
        }

 public void OnAuthentication(AuthenticationContext filterContext)
 {
     System.Diagnostics.StackFrame stackFrame = new System.Diagnostics.StackFrame();
     System.Reflection.MethodBase methodBase = stackFrame.GetMethod();
     log.Debug("Start: " + methodBase.Name);
     try
     {
         if (UserLogin.ValidateUserRequest())
         {
             filterContext.Result = new RedirectToRouteResult(new RouteValueDictionary { { "controller", "Home" }, { "action", "Login" }, { "area", "" } });
         }
         else
         {
             string context = filterContext.Controller.ControllerContext.HttpContext.Request.Path;
             int UserID = Convert.ToInt32(filterContext.HttpContext.Session["UserID"]);
             string Role = MenuBinding.CheckURlAndGetUserRole(context, UserID);
             if (Role == null)
             {
                 filterContext.Result = new RedirectToRouteResult(new RouteValueDictionary { { "controller", "Home" }, { "action", "Index" }, { "area", "" } });
             }
             filterContext.Controller.ViewBag.Role = Role;
         }
     }
     catch (Exception ex)
     {
         log.Error("Error: " + ex);
     }
     log.Debug("End: " + methodBase.Name);
 }

        /// <summary>
        /// Gets a <see cref="ILog"/> instance named after the caller's declaring or reflected type.
        /// </summary>
        public static ILog GetCurrentClassLogger()
        {
            var caller = new StackFrame(1, false).GetMethod();
            var name = (caller.DeclaringType ?? caller.ReflectedType ?? typeof(UnknownLogger)).FullName;

            return Instance.CreateLogger(name);
        }

        public override bool Include(StackFrame frame)
        {
            var method = frame.GetMethod();
            if (IsHiddenMember(method))
            {
                return false;
            }

            var type = method.DeclaringType;

            // TODO (https://github.com/dotnet/roslyn/issues/5250): look for other types indicating that we're in Roslyn code
            if (type == typeof(CommandLineRunner))
            {
                return false;
            }

            // Type is null for DynamicMethods and global methods.
            // TODO (tomat): we don't want to include awaiter helpers, shouldn't they be marked by DebuggerHidden in FX?
            if (type == null || IsTaskAwaiter(type) || IsTaskAwaiter(type.DeclaringType))
            {
                return false;
            }

            return true;
        }

        // Copied from NLog
        static string GetClassFullName()
        {
            string className;
            Type declaringType;
            int framesToSkip = 2;

            do {
#if SILVERLIGHT
                StackFrame frame = new StackTrace().GetFrame(framesToSkip);
#else
                StackFrame frame = new StackFrame(framesToSkip, false);
#endif
                MethodBase method = frame.GetMethod();
                declaringType = method.DeclaringType;
                if (declaringType == null) {
                    className = method.Name;
                    break;
                }

                framesToSkip++;
                className = declaringType.FullName;
            } while (declaringType.Module.Name.Equals("mscorlib.dll", StringComparison.OrdinalIgnoreCase));

            return className;
        }

        private static void Log(LogLevel logLevel, string msg)
        {
            if (logLevel < LogLevel) return;

            StackFrame frame = new StackFrame(2, true);
            var method = frame.GetMethod();
            var lineNumber = frame.GetFileLineNumber();

            var color = Console.ForegroundColor;
            switch (logLevel)
            {
                case LogLevel.None:
                    break;
                case LogLevel.Debug:
                    Console.ForegroundColor = ConsoleColor.DarkGray;
                    break;
                case LogLevel.Info:
                    Console.ForegroundColor = ConsoleColor.Gray;
                    break;
                case LogLevel.Warning:
                    Console.ForegroundColor = ConsoleColor.Yellow;
                    break;
                case LogLevel.Error:
                    Console.ForegroundColor = ConsoleColor.Red;
                    break;
            }

            Console.WriteLine("{0}.{1}:{2} - {3}", method.DeclaringType.FullName, method.Name, lineNumber, msg);
            Console.ForegroundColor = color;
        }

        public void Enrich(LogEvent e, out string propertyName, out object propertyValue)
        {
            var frame = new StackFrame(4);   //warning! this can change after refactoring

             propertyName = "method";

             MethodBase method = frame.GetMethod();
             var sb = new StringBuilder();

             sb.Append(method.DeclaringType.FullName);
             sb.Append(".");
             sb.Append(method.Name);
             sb.Append("(");
             bool isFirst = true;
             foreach(ParameterInfo p in method.GetParameters())
             {
            if (!isFirst)
            {
               sb.Append(", ");
            }
            else
            {
               isFirst = false;
            }
            sb.Append(p.ParameterType.Name);
            sb.Append(" ");
            sb.Append(p.Name);
             }
             sb.Append(")");

             propertyValue = sb.ToString();
        }

        public static ScopeLogger GetClassLogger(ILogTape baseLogger = null, int framesToSkip = 1)
        {
            // extracted from: https://github.com/NLog
            string loggerName;
            Type declaringType;

            do
            {
                StackFrame frame = new StackFrame(framesToSkip, false);

                var method = frame.GetMethod();
                declaringType = method.DeclaringType;
                if (declaringType == null)
                {
                    loggerName = method.Name;
                    break;
                }

                framesToSkip++;
                loggerName = declaringType.FullName;
            } while (declaringType.Module.Name.Equals("mscorlib.dll", StringComparison.OrdinalIgnoreCase));

            if (baseLogger == null)
                baseLogger = commonLogTape;

            return new ScopeLogger(loggerName, baseLogger);
        }

        public static void HandleException(Exception ex, string msg)
        {
            try
            {
                if (_exceptionUseReflection)
                {
                    var frame = new StackFrame(1);
                    frame.GetMethod();
                }
                if (ex.InnerException != null)
                {
                }
                if (!string.IsNullOrEmpty(msg))
                {
                    msg = "**************" + msg + "**************" + Environment.NewLine;
                }
                else
                {
                    msg = Environment.NewLine;
                }
                var message = (_exceptionRecurseError) ? msg + RecurseErrorStack(ex) : msg;

                if (message.Length > 0)
                {
                    Ea.GetEvent<DisplayExceptionMessage>().Publish(message);
                    Ea.GetEvent<HideBusyIndicator>().Publish(string.Empty);
                }
            }
            catch (Exception iex)
            {
                throw (new Exception("Exception in HandleException(Exception ex, string msg): " + iex.Message));
            }
        }

 public static string GetWebRootFileSystemDirectory(string debugPath = null)
 {
     string fileSystemWebRoot = null;
     try
     {
         if (!string.IsNullOrEmpty(debugPath))
         {
             var sf = new StackFrame(0, true);
             var fileName = sf.GetFileName();
             var sourceWebRootDirectory = string.IsNullOrEmpty(fileName)
                                              ? ""
                                              : Path.GetFullPath(Path.Combine(fileName, @"..\..\..", debugPath));
             fileSystemWebRoot = Directory.Exists(sourceWebRootDirectory)
                                     ? sourceWebRootDirectory
                                     : AppDomain.CurrentDomain.BaseDirectory;
         }
         else
         {
             fileSystemWebRoot = AppDomain.CurrentDomain.BaseDirectory;
         }
     }
     catch (Exception)
     {
         fileSystemWebRoot = AppDomain.CurrentDomain.BaseDirectory;
     }
     return fileSystemWebRoot;
 }

		/// <summary>
		/// 获取日志记录器（为当前类找出匹配的日志记录器）
		/// </summary>
		public ILogger GetCurrentClassLogger()
		{
			var frame = new StackFrame(2);  //调用日志记录器的类所在的堆栈帧
			Type classType = frame.GetMethod().ReflectedType;

			// 查找配置中所有匹配的日志记录器
			IList<ILogger> loggers = FindLoggers(classType);
			if (loggers.Count == 0)
			{
				return LogManager.NullLogger;
			}
			if (loggers.Count == 1)
				return loggers[0];

			MultiLogger logger = new MultiLogger(loggers);
			LogLevel minLevel = LogLevel.Fatal;
			foreach (var logger1 in loggers)
			{
				if (logger1.MinLevel < minLevel)
					minLevel = logger1.MinLevel;
			}

			logger.LoadConfig(new LoggerConfig{MinLevel = minLevel, Name = "MultiLogger"});
			return logger;
		}

 internal LogData (LogLevel level, StackFrame caller, string message)
 {
   _level = level;
   _caller = caller;
   _message = message ?? String.Empty;
   _date = DateTime.Now;
 }

 public static void Log(string message)
 {
     var trace = new StackFrame(1);
     var methodBase = trace.GetMethod();
     var type = methodBase.DeclaringType;
     LogManager.GetLogger(type).Info(message);
 }

        public static Type GetCallingType()
        {
            if (EnvironmentHelper.IsProcessHostedByTool)
            {
                return typeof(object);
            }


//#if NETFX_CORE
//            var type = typeof(object);
//#else
//            var stackTrace = StackTraceHelper.GetStackTrace();
//            var stackFrame = stackTrace.GetFrame(2);
//            var type = stackFrame.GetMethod().DeclaringType;
//#endif

#if NET
            var frame = new StackFrame(2, false);
            var type = frame.GetMethod().DeclaringType;
#elif NETFX_CORE
            var type = typeof(object);
#else
            var frame = new StackTrace().GetFrame(2);
            var type = frame.GetMethod().DeclaringType;
#endif

            return type;
        }

        public string GetLastLogin(string id)
        {
            var s = "";

            try
            {
                var query = string.Format("SELECT * from WP_GAA_Users where Unique_ID like '{0}';", id);

                using (var connection = new MySqlConnection(ConnectionString))
                {
                    connection.Open();
                    using (var cmd = new MySqlCommand(query, connection))
                    {
                        using (var r = cmd.ExecuteReader())
                        {
                            while (r.Read())
                            {
                                var loginOrdinal = r.GetOrdinal("Last_Used");
                                if (r.IsDBNull(loginOrdinal)) s = DateTime.MinValue.ToString();
                                else s = r.GetString("Last_Used");
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                var sf = new StackFrame();
                var methodBase = sf.GetMethod();
                Database.InsertErrorToDb(methodBase.Name, ex.Message, ex.ToString());
            }

            return s;
        }

        public OSAELog()
        {
            StackFrame frame = new StackFrame(1);
            MethodBase method = frame.GetMethod();
            Type type = method.DeclaringType;
            Log = LogManager.GetLogger(type);

            var root = ((log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository()).Root;
            var attachable = root as log4net.Core.IAppenderAttachable;

            if (attachable != null)
            {
                log4net.Repository.Hierarchy.Hierarchy hier = log4net.LogManager.GetRepository() as log4net.Repository.Hierarchy.Hierarchy;
                if (hier != null)
                {
                    var fileAppender =
                        (log4net.Appender.RollingFileAppender)hier.GetAppenders().Where(
                            appender => appender.Name.Equals("RollingLogFileAppender", StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();

                    var adoAppender =
                        (log4net.Appender.AdoNetAppender)hier.GetAppenders().Where(
                            appender => appender.Name.Equals("MySql_ADONetAppender", StringComparison.InvariantCultureIgnoreCase)).FirstOrDefault();

                    if (Common.TestConnection().Success)
                    {
                        if (adoAppender != null)
                        {
                            adoAppender.ConnectionString = Common.ConnectionString;
                            adoAppender.ActivateOptions();
                        }
                        root.RemoveAppender(fileAppender);
                    }
                }
            }
        }

        /// <summary>
        /// Run code in a new worker thread. WorkerDelegate should return true to end, false to repeat.
        /// </summary>
        /// <param name="worker">Delegate to be run</param>
        /// <param name="waitTime"></param>
        public static void Start(Func<bool> worker, int waitTime = 50)
        {
            if (IsRunning)
                return;

            WaitTime = waitTime;

            var frame = new StackFrame(1);
            var method = frame.GetMethod();
            var type = method.DeclaringType;
            var ns = type != null ? type.Namespace : string.Empty;

            _worker = worker;
            _thread = new Thread(SafeWorkerDelegate)
            {
                Name = string.Format("Worker: {0}.{1}", ns, type),
                IsBackground = true,
                Priority = ThreadPriority.BelowNormal,
            };

            Logger.LogDebug("Starting {0} Thread Id={1}", _thread.Name, _thread.ManagedThreadId);

            _working = true;
            _thread.Start();

            OnStarted.Invoke();
        }

        /////////////////////////////////////////////////////////////////////////////


        //////////////////////////////////////////////////////////////////////
        /// <summary>Method to trace the current call with an additional message</summary> 
        /// <param name="msg"> msg string to display</param>
        /// <param name="startFrame">the startFrame to uses</param>
        /// <param name="indent"> intendation</param>
        //////////////////////////////////////////////////////////////////////
        [Conditional("TRACE")] static private void TraceCall(string msg, StackFrame startFrame, int indent)
        {
            // puts out the callstack and the msg
            try
            {
                if (startFrame != null)
                {
                    StringBuilder  outMsg = new StringBuilder();
                    MethodBase  method = startFrame.GetMethod();

                    while (indent-- > 0)
                        outMsg.Append("    ");

                    outMsg.Append("--> " + method.DeclaringType.Name + "." + method.Name + "()");

                    if (!String.IsNullOrEmpty(msg))
                        outMsg.Append(": " + msg);

                    Tracing.TraceMsg(outMsg.ToString());
                }
                else
                {
                    Tracing.TraceMsg("Method Unknown: " + msg);
                }
                Trace.Flush();
            }
            catch 
            {
                Tracing.TraceMsg(msg);
            }
        }

        public void ShouldSetMemberfilterForMethodInfoOfTypeMethod()
        {
            StoryRunnerFilter filter = null;
            MemberInfo member = null;

            Given(
                () =>
                    {
                        var stack = new StackFrame(2); //
                        member = stack.GetMethod();
                    }
                );

            When(
                () => { filter = StoryRunnerFilter.GetFilter(member); }
                );

            Then(
                () =>
                    {
                        Assert.That(filter.MethodNameFiler.ToString(), Is.EqualTo("^ShouldSetMemberfilterForMethodInfoOfTypeMethod$"));
                        Assert.That(filter.ClassNameFilter.ToString(), Is.EqualTo("^" + typeof (StoryRunnerFilterSpecs).Name + "$"));
                        Assert.That(filter.NamespaceFilter.ToString(), Is.EqualTo("^" + typeof(StoryRunnerFilterSpecs).Namespace + "$"));
                    }
                );
        }

 public LgContextException(string condition, System.Diagnostics.StackFrame sf = null, string stackTraceString = null)
     : base(condition)
 {
     // Keep the stackframe so the editor can open the file to the right line!
     this.Sf = sf;
     this.StackTraceString = stackTraceString;
 }