public static string CaptureCodeLocation(this StackTrace source, int indentationLevel = 0)
{
var frame = source?.GetFrames()?.First();
return((frame != null
? $"FileName: {frame.GetFileName()}\tClass Name: {frame.GetMethod()?.DeclaringType?.FullName}\tMethod Name: {frame.GetMethod().Name}\tLine Number: {frame.GetFileLineNumber()}"
: "Location unknown").Indent(indentLevel: indentationLevel));
}
public static void Main()
{
StackTrace stackTrace = new StackTrace(); // get call stack
StackFrame[] stackFrames = stackTrace.GetFrames(); // get method calls (frames)
// write call stack method names
foreach (StackFrame stackFrame in stackFrames)
{
Console.WriteLine(stackFrame.GetMethod().Name); // write method name
}
}
public ExceptionInfo(Exception exception, bool isNestedException = false)
{
if (exception == null)
{
throw new ArgumentNullException(nameof(exception));
}
ErrorType = exception.GetType().Name;
ErrorMessage = exception.Message;
if (!string.IsNullOrEmpty(exception.StackTrace))
{
StackTrace stackTrace = new StackTrace(exception, true);
StackTrace = stackTrace.ToString();
// Only extract the stack frames like this for the top-level exception
// This is used for Xray Exception serialization
if (isNestedException || stackTrace?.GetFrames() == null)
{
StackFrames = new StackFrameInfo[0];
}
else
{
StackFrames = (
from sf in stackTrace.GetFrames()
where sf != null
select new StackFrameInfo(sf)
).ToArray();
}
}
if (exception.InnerException != null)
{
InnerException = new ExceptionInfo(exception.InnerException, true);
}
AggregateException aggregateException = exception as AggregateException;
if (aggregateException != null && aggregateException.InnerExceptions != null)
{
foreach (var innerEx in aggregateException.InnerExceptions)
{
InnerExceptions.Add(new ExceptionInfo(innerEx, true));
}
}
}
private void InserirErro(Exception e)
{
string sDiretorio = ConfigurationSettings.AppSettings["LogDirectory"].ToString();
if (!Directory.Exists(@sDiretorio))
Directory.CreateDirectory(@sDiretorio);
StackTrace stacktrace = new StackTrace();
StackFrame[] stackframes = stacktrace.GetFrames();
string Classe = stacktrace.GetFrame(1).GetMethod().ReflectedType.Name;
string Metodo = stacktrace.GetFrame(1).GetMethod().Name;
StreamWriter oSw = File.AppendText(@sDiretorio + "\\" + DateTime.Now.ToString("yyyyMMdd") + ".txt");
oSw.WriteLine(DateTime.Now.ToString("dd-MM-yyyy HH:mm.ss") + " > Class{ " + Classe + " } : Listar{ " + Metodo + " } - Message{ " + e.Message + " }");
oSw.Flush();
oSw.Close();
oSw = null;
}
public static string DescInfo(this StackTrace stackTrace)
{
var sb = new StringBuilder();
var sfs = stackTrace?.GetFrames();
if (sfs != null)
{
foreach (var sf in sfs)
{
var method = (MethodInfo)sf.GetMethod();
var fileName = sf.GetFileName();
if (string.IsNullOrWhiteSpace(fileName))
{
sb.AppendFormat("{0}{1}", method.DescInfo(), Environment.NewLine);
}
else
{
sb.AppendFormat("{0} in file:line:column {1}:{2}:{3}{4}", method.DescInfo(), sf.GetFileName(), sf.GetFileLineNumber(), sf.GetFileColumnNumber(), Environment.NewLine);
}
}
}
return(sb.ToString().TrimEnd(Environment.NewLine.ToArray()));
}
public Section(string name, int iColCt, SystemObject sys, object caller)
{
Name = name;
ColumnCount = iColCt;
_controls = new Dictionary <string, object>();
Sys = sys;
string myClass = caller.GetType().ToString();
StackTrace stackTrace = new StackTrace();
StackFrame[] stackFrames = stackTrace.GetFrames();
StackFrame callingFrame = stackFrames[1];
MethodInfo method = (MethodInfo)callingFrame.GetMethod();
if (method.Name == "RenderSection")
{
callingFrame = stackFrames[2];
method = (MethodInfo)callingFrame.GetMethod();
}
string sMyMethod = method.Name;
sys.ActiveSection = name;
Expanded = Sys.GetObjectValue(Name, "ExpandableSection" + myClass + sMyMethod) == "UNEXPANDED" ? false : true;
}
public static string LogExceptionMessage(Exception Ex, string MESSAGEST, bool ImportantLogFlag = true)
{
StackTrace st = new StackTrace(Ex, true);
StackFrame[] frames = st.GetFrames();
string messstr = "";
// Iterate over the frames extracting the information you need
foreach (StackFrame frame in frames)
{
messstr += String.Format("{0}:{1}({2},{3})", frame.GetFileName(), frame.GetMethod().Name, frame.GetFileLineNumber(), frame.GetFileColumnNumber());
}
string FullMessage = MESSAGEST + Environment.NewLine;
FullMessage += Environment.NewLine + Environment.NewLine + "Debug information:" + Environment.NewLine + "Exception source: " + Ex.Data + " " + Ex.Message
+ Environment.NewLine + Environment.NewLine + messstr;
//MessageBox.Show(this, FullMessage, "Invalid value", MessageBoxButtons.OK);
Logging.AddLog(MESSAGEST + ", exception: " + Ex.Message, (ImportantLogFlag ? LogLevel.Important : LogLevel.Debug), Highlight.Error);
Logging.AddLog(FullMessage, LogLevel.Debug, Highlight.Error);
return(FullMessage);
}
protected static string CreateStackTrace(string str)
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append(str);
stringBuilder.Append("\n");
StackTrace stackTrace = new StackTrace(true);
StackFrame[] frames = stackTrace.GetFrames();
for (int i = 0; i < frames.Length; i++)
{
stringBuilder.Append(string.Concat(new object[]
{
frames[i].GetFileName(),
"__",
frames[i].GetFileLineNumber(),
"__",
frames[i].GetMethod().get_Name(),
"\n"
}));
}
stringBuilder.Append("=========================================");
return(stringBuilder.ToString());
}
public static void NotNull <T>(Expression <Func <T> > parameter)
{
var memberExpression = parameter.Body as MemberExpression;
if (memberExpression == null)
{
throw new ApplicationException("Can only use a member expression with Argument.NotNull.");
}
var value = parameter.Compile().Invoke();
if (value == null)
{
var parameterName = memberExpression.Member.Name;
var stackTrace = new StackTrace(true);
var stackFrames = stackTrace.GetFrames();
var msg = "Parameter type: " + memberExpression.Type.Name + ", Function: " + stackFrames[1].GetMethod().Name;
//if (Debugger.IsAttached)
//{
// Debugger.Break();
//}
throw new ArgumentNullException(parameterName, msg);
}
}
public static void BlockingMethodCalled(this ILogger logger, StackTrace stackTrace)
{
var frames = stackTrace?.GetFrames();
//Whitelist Selz Code as recommended - many core packages use valid locking
//https://github.com/benaadams/Ben.BlockingDetector/issues/5
bool?isInternalCode = false;
if (frames != null)
{
foreach (var frame in frames)
{
if (AssemblyWhiteList.Any(wl => frame.GetMethod().ToString().Contains(wl)))
{
isInternalCode = true;
break;
}
}
}
if (isInternalCode.Value)
{
_blockingMethodCalled(logger, stackTrace, null);
}
}
public static void ArrayIndex(Expression <Func <int> > parameter)
{
var memberExpression = parameter.Body as MemberExpression;
if (memberExpression == null)
{
throw new ApplicationException("Can only use a member expression with Argument.ArrayIndex.");
}
if (memberExpression.Type != typeof(int))
{
throw new ApplicationException("ArrayIndex can only be used with int arguments, type was " + memberExpression.Type.Name);
}
var value = parameter.Compile().Invoke();
if (value < 0)
{
var parameterName = memberExpression.Member.Name;
var stackTrace = new StackTrace(true);
var stackFrames = stackTrace.GetFrames();
throw new ArgumentException("Negative array index is invalid. Function: " + stackFrames[1].GetMethod().Name, parameterName);
}
}
private static void Write(string logType, string strLog, bool isHour = false)
{
var logStr = new StringBuilder(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff | "));
try
{
var trace = new StackTrace();
var frames = trace.GetFrames().Reverse().ToList();
frames = frames.Skip(frames.FindLastIndex(a => a.GetMethod().ReflectedType.FullName.StartsWith("System.")) + 1).ToList();
foreach (var frame in frames)
{
var method = frame.GetMethod();
if (method.ReflectedType.FullName.StartsWith("Utility."))
{
continue;
}
logStr.Append(method.ReflectedType.FullName).Append(".").Append(method.Name).Append(" -> ");
}
}
catch
{
}
var logDirectory = AppDomain.CurrentDomain.BaseDirectory + @"\App_Log\" + logType + @"\";
string logFile;
if (isHour)
{
logFile = logDirectory + DateTime.Now.ToString("yyyy-MM-dd-HH") + ".log";
}
else
{
logFile = logDirectory + DateTime.Now.ToString("yyyy-MM-dd") + ".log";
}
Mutex mutexFile = null;
try
{
mutexFile = new Mutex(false, logFile);
mutexFile.WaitOne();
}
catch
{
}
try
{
if (strLog != null)
{
logStr.Append(strLog);
}
if (!Directory.Exists(logDirectory))
{
Directory.CreateDirectory(logDirectory);
}
using (var fs = new FileStream(logFile, FileMode.Append, FileAccess.Write))
{
using (var writer = new StreamWriter(fs, Encoding.UTF8))
{
writer.WriteLine(logStr.ToString());
}
}
}
catch
{
}
if (mutexFile != null)
{
try
{
mutexFile.ReleaseMutex();
mutexFile.Close();
}
catch
{
}
}
}
/// <summary>
/// _s the get method stack trace.
/// </summary>
/// <returns>
/// The get method stack trace.
/// </returns>
/// <param name='aMessage_string'>
/// A message_string.
/// </param>
private static string _GetMethodStackTrace(string aMessage_string)
{
StackTrace stackTrace = new StackTrace();
StackFrame[] stackFrames = stackTrace.GetFrames();
string output_string = "";
output_string += aMessage_string;
string spaces_string = " ";
StackFrame stackFrame;
for (int count_int = 2 ; count_int < stackFrames.Length; count_int ++ ) {
stackFrame = stackFrames[count_int];
output_string += "\n" + (spaces_string + stackFrame.GetMethod());
spaces_string += " ";
}
return output_string;
}
public static StackFrame GetFrame(this StackTrace strackTrace, int number)
{
return(strackTrace.GetFrames()[number]);
}
public void subir()
{
if (GvSubir.Rows.Count < 1)
{
String mensajeScriptnm = @"<script type='text/javascript'>
swal({
title: ""Seleccione Txt"",
icon: ""warning"",
dangerMode: false,
})
</script>";
ScriptManager.RegisterStartupScript(this, typeof(Page), "mensaje", mensajeScriptnm, false);
FileUpload1.Focus();
return;
}
Int32 IdUsuario = Convert.ToInt32(Request.Cookies["WebNestle"]["DLIdUsuario"]);
String Msj = "";
try {
foreach (GridViewRow row in GvSubir.Rows)
{
Msj = obj.SubirPedidoSugeridoCliente(row.Cells[0].Text.ToString(), Convert.ToDouble(row.Cells[1].Text.ToString()), IdUsuario);
}
}
catch (Exception ex)
{
StackTrace st = new StackTrace(ex, true);
StackFrame frame = st.GetFrames().Where(f => !String.IsNullOrEmpty(f.GetFileName()) &&
f.GetILOffset() != StackFrame.OFFSET_UNKNOWN &&
f.GetNativeOffset() != StackFrame.OFFSET_UNKNOWN &&
!f.GetMethod().Module.Assembly.GetName().Name.Contains("mscorlib")).First();
string MachineName = System.Environment.MachineName;
string UserName = System.Environment.UserName.ToUpper();
string Mensaje = ex.Message;
StringBuilder builder = new StringBuilder(Mensaje);
builder.Replace("'", "");
int LineaError = frame.GetFileLineNumber();
string Proyecto = frame.GetMethod().Module.Assembly.GetName().Name;
string Clase = frame.GetMethod().DeclaringType.Name;
string metodo = frame.GetMethod().Name;
String M = "Formato Incorrecto";
string menssajeScript = "<script type='text/javascript'>"
+ " swal({" +
"title: '" + M.ToString() + "'," +
" icon: 'warning'," +
" dangerMode: false," +
" }) </script>";
ScriptManager.RegisterStartupScript(this, typeof(Page), "mensaje", menssajeScript, false);
return;
}
if (Msj != "")
{
string menssajeScript = "<script type='text/javascript'>"
+ " swal({" +
"title: '" + Msj + "'," +
" icon: 'success'," +
" dangerMode: false," +
" }) </script>";
ScriptManager.RegisterStartupScript(this, typeof(Page), "mensaje", menssajeScript, false);
PanelListar.Visible = true;
PanelSubir.Visible = false;
ListarClienteSugerido();
LblTotal.Text = "";
}
else
{
string menssajeScript = "<script type='text/javascript'>"
+ " swal({" +
"title: 'ocurrio un error'," +
" icon: 'warning'," +
" dangerMode: true," +
" }) </script>";
ScriptManager.RegisterStartupScript(this, typeof(Page), "mensaje", menssajeScript, false);
}
DataTable dt = new DataTable();
GvSubir.DataSource = dt;
GvSubir.DataBind();
ListarClienteSugerido();
}
/// <summary>
/// Commands the executing.
/// </summary>
/// <param name="command">The command.</param>
/// <param name="interceptionContext">The interception context.</param>
/// <param name="userState">State of the user.</param>
/// <inheritdoc />
private void CommandExecuting(DbCommand command, DbCommandInterceptionContext interceptionContext, out object userState)
{
userState = null;
if (!interceptionContext.DbContexts.Any(a => this.DbContextList.Contains(a) || this.EnableForAllDbContexts))
{
return;
}
DebugHelper._callCounts++;
StringBuilder sbDebug = new StringBuilder();
sbDebug.AppendLine("\n");
StackTrace st = new StackTrace(2, true);
var frames = st.GetFrames().Where(a => a.GetFileName() != null);
sbDebug.AppendLine(string.Format("/* Call# {0}*/", DebugHelper._callCounts));
sbDebug.AppendLine(string.Format("/*\n{0}*/", frames.ToList().AsDelimited("")));
sbDebug.AppendLine("BEGIN\n");
var declares = command.Parameters.OfType <System.Data.SqlClient.SqlParameter>()
.Select(p =>
{
if (p.SqlDbType == System.Data.SqlDbType.NVarChar)
{
var sqlString = ( SqlString )p.SqlValue;
string sqlValue = sqlString.IsNull ? "null" : sqlString.Value?.Truncate(255);
return(string.Format("@{0} {1}({2}) = '{3}'", p.ParameterName, p.SqlDbType, p.Size, sqlValue?.Replace("'", "''")));
}
if (p.SqlDbType == System.Data.SqlDbType.Int)
{
return(string.Format("@{0} {1} = {2}", p.ParameterName, p.SqlDbType, p.SqlValue ?? "null"));
}
else if (p.SqlDbType == System.Data.SqlDbType.Udt)
{
return(string.Format("@{0} {1} = '{2}'", p.ParameterName, p.UdtTypeName, p.SqlValue));
}
else if (p.SqlDbType == System.Data.SqlDbType.Bit)
{
return(string.Format("@{0} {1} = {2}", p.ParameterName, p.SqlDbType, ((System.Data.SqlTypes.SqlBoolean)p.SqlValue).ByteValue));
}
else if (p.SqlDbType == System.Data.SqlDbType.Decimal)
{
return(string.Format("@{0} {1} = {2}", p.ParameterName, p.SqlDbType, p.SqlValue ?? "null"));
}
else
{
return(string.Format("@{0} {1} = '{2}'", p.ParameterName, p.SqlDbType, p.SqlValue));
}
}).ToList().AsDelimited(",\n");
if (!string.IsNullOrEmpty(declares))
{
sbDebug.AppendLine("DECLARE\n" + declares + "\n\n");
}
sbDebug.AppendLine(command.CommandText);
sbDebug.AppendLine("\nEND\nGO\n\n");
System.Diagnostics.Debug.Write(sbDebug.ToString());
var sqlConnection = command.Connection as System.Data.SqlClient.SqlConnection;
sqlConnection.StatisticsEnabled = true;
sqlConnection.ResetStatistics();
if (userState == null)
{
userState = new DebugHelperUserState {
CallNumber = DebugHelper._callCounts, Stopwatch = Stopwatch.StartNew()
};
}
}
private static void FirstChanceExceptionHandler(object sender, FirstChanceExceptionEventArgs args)
{
if (handlerActive.Value)
{
return;
}
bool oom = args.Exception is OutOfMemoryException;
//In case of OOM, unload the Main.tile array and do immediate garbage collection.
//If we don't do this, there will be a big chance that this method will fail to even quit the game, due to another OOM exception being thrown.
if (oom)
{
Main.tile = null;
GC.Collect();
}
try {
handlerActive.Value = true;
if (!oom)
{
if (args.Exception == previousException ||
args.Exception is ThreadAbortException ||
ignoreSources.Contains(args.Exception.Source) ||
ignoreMessages.Any(str => args.Exception.Message?.Contains(str) ?? false) ||
ignoreThrowingMethods.Any(str => args.Exception.StackTrace?.Contains(str) ?? false))
{
return;
}
}
var stackTrace = new StackTrace(true);
PrettifyStackTraceSources(stackTrace.GetFrames());
var traceString = stackTrace.ToString();
if (!oom && ignoreContents.Any(traceString.Contains))
{
return;
}
traceString = traceString.Substring(traceString.IndexOf('\n'));
var exString = args.Exception.GetType() + ": " + args.Exception.Message + traceString;
lock (pastExceptions) {
if (!pastExceptions.Add(exString))
{
return;
}
}
previousException = args.Exception;
var msg = args.Exception.Message + " " + Language.GetTextValue("tModLoader.RuntimeErrorSeeLogsForFullTrace", Path.GetFileName(LogPath));
#if CLIENT
if (ModCompile.activelyModding)
{
AddChatMessage(msg, Color.OrangeRed);
}
#else
Console.ForegroundColor = ConsoleColor.DarkMagenta;
Console.WriteLine(msg);
Console.ResetColor();
#endif
tML.Warn(Language.GetTextValue("tModLoader.RuntimeErrorSilentlyCaughtException") + '\n' + exString);
if (oom)
{
const string error = "Game ran out of memory. You'll have to find which mod is consuming lots of memory, and contact the devs or remove it.";
Logging.tML.Fatal(error);
Interface.MessageBoxShow(error);
Environment.Exit(1);
}
}
catch (Exception e) {
tML.Warn("FirstChanceExceptionHandler exception", e);
}
finally {
handlerActive.Value = false;
}
}
protected override void Write(LogEventInfo logEvent)
{
var record = new Dictionary <string, object> {
{ "level", logEvent.Level.Name },
{ "message", Layout.Render(logEvent) },
{ "logger_name", logEvent.LoggerName },
{ "sequence_id", logEvent.SequenceID },
};
if (this.EmitStackTraceWhenAvailable && logEvent.HasStackTrace)
{
var transcodedFrames = new List <Dictionary <string, object> >();
StackTrace stackTrace = logEvent.StackTrace;
foreach (StackFrame frame in stackTrace.GetFrames())
{
var transcodedFrame = new Dictionary <string, object>
{
{ "filename", frame.GetFileName() },
{ "line", frame.GetFileLineNumber() },
{ "column", frame.GetFileColumnNumber() },
{ "method", frame.GetMethod().ToString() },
{ "il_offset", frame.GetILOffset() },
{ "native_offset", frame.GetNativeOffset() },
};
transcodedFrames.Add(transcodedFrame);
}
record.Add("stacktrace", transcodedFrames);
}
if (this.IncludeAllProperties && logEvent.Properties.Count > 0)
{
foreach (var property in logEvent.Properties)
{
var propertyKey = property.Key.ToString();
if (string.IsNullOrEmpty(propertyKey))
{
continue;
}
record[propertyKey] = SerializePropertyValue(propertyKey, property.Value);
}
}
try
{
EnsureConnected();
}
catch (Exception ex)
{
NLog.Common.InternalLogger.Warn("Fluentd Connect - " + ex.ToString());
throw; // Notify NLog of failure
}
try
{
this.emitter?.Emit(logEvent.TimeStamp, this.Tag, record);
}
catch (Exception ex)
{
NLog.Common.InternalLogger.Warn("Fluentd Emit - " + ex.ToString());
throw; // Notify NLog of failure
}
}
// Return the source code location of the caller located callDepth frames up the stack.
// ICU4N NOTE: In order for this to work in .NET Standard 1.x in Release mode, the
// [MethodImpl(MethodImplOptions.NoInlining)] attribute must be added to each method/property this
// searches for.
protected static string SourceLocation()
{
#if !FEATURE_STACKTRACE
var sourceLines =
Environment.StackTrace
.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Reverse().ToList();
using (var iter = sourceLines.GetEnumerator())
{
while (iter.MoveNext())
{
var line = iter.Current;
if (line.Contains("System.Environment.GetStackTrace") || line.Contains("get_StackTrace"))
{
continue;
}
if (line.TrimStart().StartsWith("at NUnit.", StringComparison.Ordinal) || line.TrimStart().StartsWith("at Microsoft.VisualStudio", StringComparison.Ordinal) || line.Contains("Invoke"))
{
continue;
}
if (line.Contains("TestFmwk.cs") || line.Contains("AbstractTestLog.cs"))
{
continue;
}
var match = MethodNameRegex.Match(line);
if (match.Success)
{
var methodName = match.Groups["method"].Value;
if (methodName.StartsWith("Test", StringComparison.Ordinal) || methodName.StartsWith("test", StringComparison.Ordinal) || methodName.Equals("Main"))
{
var matchFileName = FileNameRegex.Match(line);
if (matchFileName.Success)
{
return(matchFileName.Groups["filename"].Value);
}
// If the regex fails, just return the line as is.
return(line);
}
}
}
}
#else
// Walk up the stack to the first call site outside this file
StackTrace trace = new StackTrace(true);
foreach (var frame in trace.GetFrames())
{
string source = frame.GetFileName();
if (source != null && !source.EndsWith("TestFmwk.cs", StringComparison.Ordinal) && !source.EndsWith("AbstractTestLog.cs", StringComparison.Ordinal))
{
string methodName = frame.GetMethod().Name;
if (methodName != null &&
(methodName.StartsWith("Test", StringComparison.Ordinal) || methodName.StartsWith("test", StringComparison.Ordinal) || methodName.Equals("Main")))
{
return("(" + source + ":" + frame.GetFileLineNumber() + ") ");
}
}
}
#endif
throw new Exception();
}
/// <summary>
/// Appends the exception.
/// </summary>
/// <param name="title">The title.</param>
/// <param name="ex">The ex.</param>
/// <param name="exceptionLevel">The exception level.</param>
public void AppendException(String title, Exception ex, Int32 exceptionLevel = 0)
{
lock (AppendExceptionLock)
{
throw new aceGeneralException("Exception: " + ex.Message, ex, this, title);
open("Exception", title);
if (ex == null)
{
AppendLine("Exception: [null]");
return;
}
ex.describe(this, "");
callerInfo ci = null;
StackFrame[] frames = null;
if (ex is aceGeneralException)
{
aceGeneralException axe = (aceGeneralException)ex;
ci = axe.callInfo;
}
else
{
StackTrace st = new StackTrace(ex, true);
StackFrame sf = st.GetFrame(0);
if (sf == null)
{
aceGeneralException axe = new aceGeneralException("WrapperException for " + ex.GetType().Name, ex, this, title);
ci = axe.callInfo;
}
else
{
ci = callerInfo.getCallerInfo(sf, true);
}
frames = st.GetFrames();
}
if (exceptionLevel == 0)
{
AppendTable(ci.AppendDataFields());
}
AppendTable(ci.AppendDataFieldsOfMethod());
open("parents", "Parent StackFrames");
List <String> sfi_strings = new List <string>();
Int32 c = 0;
if (frames != null)
{
foreach (StackFrame sfi in frames)
{
if (c != 0)
{
open("frame", "StackFrame(" + c.ToString() + ")");
callerInfo sfi_ci = callerInfo.getCallerInfo(sfi, true);
AppendTable(sfi_ci.AppendDataFieldsOfMethod());
close();
}
c++;
//sfi.GetFileLineNumb
}
}
close();
if (ex.InnerException != null)
{
AppendException("InnerException [level:" + exceptionLevel + "]", ex.InnerException, exceptionLevel + 1);
}
close();
}
}
private void AddToTraceResult(Stopwatch watch)
{
int CurrentThreadID = Thread.CurrentThread.ManagedThreadId;
int TraceResultThreadIndex;
lock (_locker)
{
TraceResultThreadIndex = GetTraceResultThreadIndex(CurrentThreadID);
if (TraceResultThreadIndex == -1)
{
_result.Add(new ThreadItem(CurrentThreadID));
TraceResultThreadIndex = _result.Count - 1;
}
}
StackTrace st = new StackTrace();
StackFrame sf = st.GetFrame(2);
var item = new MethodItem()
{
MethodName = sf.GetMethod().Name,
MethodClassName = sf.GetMethod().DeclaringType.Name,
ElapsedMilliseconds = 0,
SubMethods = null,
};
lock (_locker)
{
if (_stacks.ContainsKey(CurrentThreadID))
{
_stacks[CurrentThreadID].TraceWatches.Push((watch, item));
}
else
{
var stack = new ThreadStack();
stack.TraceWatches.Push((watch, item));
_stacks.Add(CurrentThreadID, stack);
}
InsertIntoTree((_result[TraceResultThreadIndex] as ThreadItem).SubMethods, item, st.GetFrames());
}
}
/// <summary>
/// _s the get method stack trace.
/// </summary>
/// <returns>
/// The get method stack trace.
/// </returns>
/// <param name='aMessage_string'>
/// A message_string.
/// </param>
private static string _GetMethodStackTrace(string aMessage_string)
{
StackTrace stackTrace = new StackTrace();
StackFrame[] stackFrames = stackTrace.GetFrames();
string output_string = "";
output_string += aMessage_string;
string spaces_string = " ";
StackFrame stackFrame;
//WE don't show'Debug.LogStackTrace()' in result by controlling 'for' loop
for (int count_int = stackFrames.Length -1 ; count_int > 1; count_int -- ) {
stackFrame = stackFrames[count_int];
output_string += "\n" + (spaces_string + stackFrame.GetMethod().DeclaringType.Name + "." + stackFrame.GetMethod().Name + "()");
spaces_string += " ";
}
return output_string;
}
public Promise()
{
Fulfilled = false;
var stackTrace = new StackTrace();
var stackFrames = stackTrace.GetFrames();
From = stackFrames.Aggregate("", (s, frame) => s + " -> " + frame.GetMethod().Name);
}
public void LogSessionTimeOut(Hashtable State, string page)
{
if (State == null)
{
throw new Exception("Timeout with no State or Session");
}
StackTrace stackTrace = new StackTrace(); // get call stack
StackFrame[] stackFrames = stackTrace.GetFrames(); // get method calls (frames)
// write call stack method names
StringBuilder stack = new StringBuilder();
bool isFirst = true;
foreach (StackFrame stackFrame in stackFrames)
{
if (isFirst)
isFirst = false;
else
stack.Append("<-");
stack.Append(stackFrame.GetMethod().Name); // write method name
}
StringBuilder values = new StringBuilder();
if (State.Keys.Count > 0)
{
isFirst = true;
foreach (string key in State.Keys)
{
if (isFirst)
isFirst = false;
else
values.Append(", ");
if (State[key] != null)
values.Append(key + "=" + State[key].ToString());
else
values.Append(key + "=null");
}
}
string info = "cache values: " + values.ToString();
string trace = "timeout: " + info + "; stack: " + stack.ToString();
UpdateSessionLog(State, trace, page);
}
/// <summary>
/// Create .lnk to ClickOnce shortcut with autostart parameters
/// </summary>
public static void CreateAutoStartLink()
{
Logging.AddLog("CreateAutoStartLink enter", LogLevel.Debug);
try
{
ApplicationDeployment ad = ApplicationDeployment.CurrentDeployment;
if (ad.IsFirstRun)
{
Logging.AddLog("Creating autostart link file", LogLevel.Debug);
Assembly assembly = Assembly.GetEntryAssembly();
string company = string.Empty;
string description = string.Empty;
string productname = string.Empty;
string StartMenuShortcutName = string.Empty;
// Get company name
if (Attribute.IsDefined(assembly, typeof(AssemblyCompanyAttribute)))
{
AssemblyCompanyAttribute ascompany = (AssemblyCompanyAttribute)Attribute.GetCustomAttribute(assembly, typeof(AssemblyCompanyAttribute));
company = ascompany.Company;
}
// Get shortcut description
if (Attribute.IsDefined(assembly, typeof(AssemblyDescriptionAttribute)))
{
AssemblyDescriptionAttribute asdescription = (AssemblyDescriptionAttribute)Attribute.GetCustomAttribute(assembly, typeof(AssemblyDescriptionAttribute));
description = asdescription.Description;
}
// Get shortcut product name
if (Attribute.IsDefined(assembly, typeof(AssemblyProductAttribute)))
{
AssemblyProductAttribute asproduct = (AssemblyProductAttribute)Attribute.GetCustomAttribute(assembly, typeof(AssemblyProductAttribute));
productname = asproduct.Product;
}
Logging.AddLog(company + " | " + description + " | " + productname, LogLevel.Debug);
// Concat clickonce shortcut full path
if (!string.IsNullOrEmpty(company))
{
StartMenuShortcutName = string.Concat(
Environment.GetFolderPath(Environment.SpecialFolder.Programs),
"\\",
company,
"\\",
productname,
".appref-ms");
}
//if everything is ok - create shortcut
if (!string.IsNullOrEmpty(StartMenuShortcutName))
{
string desktopPath = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory);
Utils.CreateLink(_PROGRAM_AUTOSTART_SHORTCUT_NAME, desktopPath, StartMenuShortcutName, "-start");
}
else
{
Logging.AddLog("Couldn't locate ClickOnce shortcut in start menu", LogLevel.Debug);
}
}
}
catch (Exception ex)
{
StackTrace st = new StackTrace(ex, true);
StackFrame[] frames = st.GetFrames();
string messstr = "";
// Iterate over the frames extracting the information you need
foreach (StackFrame frame in frames)
{
messstr += String.Format("{0}:{1}({2},{3})", frame.GetFileName(), frame.GetMethod().Name, frame.GetFileLineNumber(), frame.GetFileColumnNumber());
}
string FullMessage = "Error in creating Autostart link. ";
FullMessage += "IOException source: " + ex.Data + " | " + ex.Message + " | " + messstr;
Logging.AddLog(FullMessage, LogLevel.Important);
}
Logging.AddLog("CreateAutoStartLink exit", LogLevel.Trace);
}
public void TestDMD()
{
Counter = 0;
// Run the original method.
Assert.Equal(Tuple.Create(StringOriginal, 1), ExampleMethod(1));
MethodInfo original = typeof(DynamicMethodDefinitionTest).GetMethod(nameof(ExampleMethod));
MethodBase patched;
using (DynamicMethodDefinition dmd = new DynamicMethodDefinition(original)) {
Assert.Equal("i", dmd.Definition.Parameters[0].Name);
// Modify the MethodDefinition.
foreach (Instruction instr in dmd.Definition.Body.Instructions)
{
if (instr.Operand as string == StringOriginal)
{
instr.Operand = StringPatched;
}
else if (instr.MatchCallOrCallvirt <DynamicMethodDefinitionTest>(nameof(ExampleMethod)))
{
instr.Operand = dmd.Definition;
}
}
// Generate a DynamicMethod from the modified MethodDefinition.
patched = dmd.Generate();
}
// Generate an entirely new method that just returns a stack trace for further testing.
DynamicMethod stacker;
using (DynamicMethodDefinition dmd = new DynamicMethodDefinition("Stacker", typeof(StackTrace), new Type[0])) {
using (ILContext il = new ILContext(dmd.Definition))
il.Invoke(_ => {
ILCursor c = new ILCursor(il);
for (int i = 0; i < 32; i++)
{
c.Emit(OpCodes.Nop);
}
c.Emit(OpCodes.Newobj, typeof(StackTrace).GetConstructor(new Type[0]));
for (int i = 0; i < 32; i++)
{
c.Emit(OpCodes.Nop);
}
c.Emit(OpCodes.Ret);
});
stacker = (DynamicMethod)DMDEmitDynamicMethodGenerator.Generate(dmd, null);
}
using (DynamicMethodDefinition dmd = new DynamicMethodDefinition(typeof(ExampleGenericClass <int>).GetMethod(nameof(ExampleMethod)))) {
Assert.Equal(0, ((Func <int>)dmd.Generate().CreateDelegate(typeof(Func <int>)))());
Assert.Equal(0, ((Func <int>)DMDCecilGenerator.Generate(dmd).CreateDelegate(typeof(Func <int>)))());
Assert.Equal(dmd.Name = "SomeManualDMDName", dmd.Generate().Name);
Counter -= 2;
// This was indirectly provided by Pathoschild (SMAPI).
// Microsoft.GeneratedCode can be loaded multiple times and have different contents.
// This tries to recreate that scenario... and this is the best place to test it at the time of writing.
#if NETFRAMEWORK && true
AssemblyBuilder abDupeA = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName()
{
Name = "MonoMod.UnitTest.AssemblyDupe"
},
AssemblyBuilderAccess.RunAndSave
);
ModuleBuilder mbDupeA = abDupeA.DefineDynamicModule($"{abDupeA.GetName().Name}.dll");
TypeBuilder tbDupeA = mbDupeA.DefineType(
"DupeA",
System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.Abstract | System.Reflection.TypeAttributes.Sealed | System.Reflection.TypeAttributes.Class
);
Type tDupeA = tbDupeA.CreateType();
AssemblyBuilder abDupeB = AppDomain.CurrentDomain.DefineDynamicAssembly(
new AssemblyName()
{
Name = abDupeA.GetName().Name
},
AssemblyBuilderAccess.RunAndSave
);
ModuleBuilder mbDupeB = abDupeB.DefineDynamicModule($"{abDupeB.GetName().Name}.dll");
TypeBuilder tbDupeB = mbDupeB.DefineType(
"DupeB",
System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.Abstract | System.Reflection.TypeAttributes.Sealed | System.Reflection.TypeAttributes.Class
);
Type tDupeB = tbDupeB.CreateType();
Assert.Equal(tDupeA.Assembly.FullName, tDupeB.Assembly.FullName);
Assert.NotEqual(tDupeA.Assembly, tDupeB.Assembly);
TypeReference trDupeA = dmd.Module.ImportReference(tDupeA);
TypeReference trDupeB = dmd.Module.ImportReference(tDupeB);
Assert.Equal(trDupeA.Scope.Name, trDupeB.Scope.Name);
// "Fun" fact: both share matching AssemblyNames, so the first scope gets reused!
// Assert.NotEqual(trDupeA.Scope, trDupeB.Scope);
Assert.Equal(tDupeA, trDupeA.ResolveReflection());
Assert.Equal(tDupeB, trDupeB.ResolveReflection());
#endif
}
// Run the DynamicMethod.
Assert.Equal(Tuple.Create(StringPatched, 3), patched.Invoke(null, new object[] { 2 }));
Assert.Equal(Tuple.Create(StringPatched, 3), patched.Invoke(null, new object[] { 1337 }));
// Detour the original method to the patched DynamicMethod, then run the patched method.
using (new Detour(original, patched)) {
// The detour is only active in this block.
Assert.Equal(Tuple.Create(StringPatched, 6), ExampleMethod(3));
}
// Run the original method again.
Assert.Equal(Tuple.Create(StringOriginal, 10), ExampleMethod(4));
// Verify that we can still obtain the real DynamicMethod.
// .NET uses a wrapping RTDynamicMethod to avoid leaking the mutable DynamicMethod.
// Mono uses RuntimeMethodInfo without any link to the original DynamicMethod.
if (Type.GetType("Mono.Runtime") != null)
{
stacker.Pin();
}
StackTrace stack = ((Func <StackTrace>)stacker.CreateDelegate(typeof(Func <StackTrace>)))();
MethodBase stacked = stack.GetFrames().First(f => f.GetMethod()?.IsDynamicMethod() ?? false).GetMethod();
Assert.NotEqual(stacker, stacked);
Assert.Equal(stacker, stacked.GetIdentifiable());
Assert.Equal(stacker.GetNativeStart(), stacked.GetNativeStart());
// This will always be true on .NET and only be true on Mono if the method is still pinned.
Assert.IsAssignableFrom <DynamicMethod>(stacked.GetIdentifiable());
if (Type.GetType("Mono.Runtime") != null)
{
stacker.Unpin();
}
}
public static ExceptionInfo GetExceptionInfo(Exception exception, ExtensionFactory extensions)
{
try
{
var playniteStackCalls = 0;
var stack = new StackTrace(exception);
var crashModules = new List <Module>();
foreach (var frame in stack.GetFrames())
{
var module = frame.GetMethod().Module;
if (module.Name.StartsWith("Playnite"))
{
playniteStackCalls++;
}
crashModules.AddMissing(module);
}
if (exception.InnerException != null)
{
stack = new StackTrace(exception.InnerException);
foreach (var frame in stack.GetFrames())
{
var module = frame.GetMethod().Module;
if (module.Name.StartsWith("Playnite"))
{
playniteStackCalls++;
}
crashModules.AddMissing(module);
}
}
var extDesc = extensions?.Plugins?.FirstOrDefault(a =>
crashModules.FirstOrDefault(m => m.Name ==
a.Value.Description.Module ||
Paths.AreEqual(a.Value.Description.DirectoryPath, Path.GetDirectoryName(m.Assembly.Location))) != null).Value;
if (extDesc != null)
{
return(new ExceptionInfo
{
IsExtensionCrash = true,
CrashExtension = extDesc.Description
});
}
else
{
// This usually happens if an exception occurs in XAML because of faulty custom theme.
// The only stack entry would be Playnite's entry point or no entry at all.
if (playniteStackCalls == 0 || playniteStackCalls == 1)
{
return(new ExceptionInfo {
IsExtensionCrash = true
});
}
else
{
return(new ExceptionInfo());
}
}
}
catch (Exception e) when(!PlayniteEnvironment.ThrowAllErrors)
{
logger.Error(e, "Failed check crash stack trace.");
return(new ExceptionInfo());
}
}
private AirbrakeTraceLine[] BuildBacktrace(Exception exception, out MethodBase catchingMethod)
{
Assembly assembly = Assembly.GetExecutingAssembly();
if (assembly.EntryPoint == null)
{
assembly = Assembly.GetCallingAssembly();
}
if (assembly.EntryPoint == null)
{
assembly = Assembly.GetEntryAssembly();
}
catchingMethod = assembly == null
? null
: assembly.EntryPoint;
List <AirbrakeTraceLine> lines = new List <AirbrakeTraceLine>();
var stackTrace = new StackTrace(exception);
StackFrame[] frames = stackTrace.GetFrames();
if (frames == null || frames.Length == 0)
{
// Airbrake requires that at least one line is present in the XML.
AirbrakeTraceLine line = new AirbrakeTraceLine("none", 0);
lines.Add(line);
return(lines.ToArray());
}
foreach (StackFrame frame in frames)
{
MethodBase method = frame.GetMethod();
catchingMethod = method;
int lineNumber = frame.GetFileLineNumber();
if (lineNumber == 0)
{
this.log.Debug(f => f("No line number found in {0}, using IL offset instead.", method));
lineNumber = frame.GetILOffset();
}
string file = frame.GetFileName();
if (String.IsNullOrEmpty(file))
{
// ReSharper disable ConditionIsAlwaysTrueOrFalse
file = method.ReflectedType != null
? method.ReflectedType.FullName
: "(unknown)";
// ReSharper restore ConditionIsAlwaysTrueOrFalse
}
AirbrakeTraceLine line = new AirbrakeTraceLine(file, lineNumber)
{
Method = method.Name
};
lines.Add(line);
}
return(lines.ToArray());
}
public static DynamicStackFrame[] GetDynamicStackFrames(Exception e, bool filter)
{
List <DynamicStackFrame> frames = e.Data[typeof(DynamicStackFrame)] as List <DynamicStackFrame>;
if (frames == null)
{
// we may have missed a dynamic catch, and our host is looking
// for the exception...
frames = ExceptionHelpers.AssociateDynamicStackFrames(e);
ExceptionHelpers.DynamicStackFrames = null;
}
if (frames == null)
{
return(new DynamicStackFrame[0]);
}
if (!filter)
{
return(frames.ToArray());
}
#if !SILVERLIGHT
frames = new List <DynamicStackFrame>(frames);
List <DynamicStackFrame> res = new List <DynamicStackFrame>();
// the list of _stackFrames we build up in ScriptingRuntimeHelpers can have
// too many frames if exceptions are thrown from script code and
// caught outside w/o calling GetDynamicStackFrames. Therefore we
// filter down to only script frames which we know are associated
// w/ the exception here.
try {
StackTrace outermostTrace = new StackTrace(e);
IList <StackTrace> otherTraces = ExceptionHelpers.GetExceptionStackTraces(e) ?? new List <StackTrace>();
List <StackFrame> clrFrames = new List <StackFrame>();
foreach (StackTrace trace in otherTraces)
{
clrFrames.AddRange(trace.GetFrames() ?? new StackFrame[0]); // rare, sometimes GetFrames returns null
}
clrFrames.AddRange(outermostTrace.GetFrames() ?? new StackFrame[0]); // rare, sometimes GetFrames returns null
int lastFound = 0;
foreach (StackFrame clrFrame in InterpretedFrame.GroupStackFrames(clrFrames))
{
MethodBase method = clrFrame.GetMethod();
for (int j = lastFound; j < frames.Count; j++)
{
MethodBase other = frames[j].GetMethod();
// method info's don't always compare equal, check based
// upon name/module/declaring type which will always be a correct
// check for dynamic methods.
if (method.Module == other.Module &&
method.DeclaringType == other.DeclaringType &&
method.Name == other.Name)
{
res.Add(frames[j]);
frames.RemoveAt(j);
lastFound = j;
break;
}
}
}
} catch (MemberAccessException) {
// can't access new StackTrace(e) due to security
}
return(res.ToArray());
#else
return(frames.ToArray());
#endif
}
/// <summary>
/// Gets all static rules defined on the specified types.
/// </summary>
/// <param name="types"></param>
/// <returns></returns>
public static IEnumerable <Rule> GetRules(IEnumerable <Type> types)
{
// Fetch the set of rules declared on the specified types
List <Rule> rules = new List <Rule>();
foreach (Type type in types
.Where(type => type.IsClass)
.SelectMany(type => type.BaseType.IsGenericType ? new Type[] { type, type.BaseType } : new Type[] { type }))
{
rules.AddRange(
type.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
.Where(field => typeof(IRuleProvider).IsAssignableFrom(field.FieldType))
.SelectMany(field =>
{
IRuleProvider ruleProvider = (IRuleProvider)field.GetValue(null);
if (ruleProvider != null)
{
return(ruleProvider.GetRules(type, field.Name));
}
else
{
StackTrace stackTrace = new StackTrace();
List <MethodBase> callStackMethods = stackTrace.GetFrames()
.Select(f => f.GetMethod())
.ToList();
Type currentType = callStackMethods.First().DeclaringType;
callStackMethods.Reverse();
MethodBase ruleProviderCall = callStackMethods.FirstOrDefault(method => currentType != method.DeclaringType && typeof(IRuleProvider).IsAssignableFrom(method.DeclaringType));
if (ruleProviderCall != null)
{
string errorMessage = string.Format(
"'{0}'.'{1}' is null, declared as a '{2}', and '{3}'.'{4}' is creating/accessing rules. As such, it appears that the '{2}' is still initializing and rules will not register properly. Please see the call stack.",
type.Name, field.Name, typeof(IRuleProvider).Name, ruleProviderCall.DeclaringType.Name, ruleProviderCall.Name
);
throw new ApplicationException(errorMessage);
}
}
return(new Rule[] { });
})
.Where(rule => rule != null)
);
// Ensure the error code has been set on all statically declared condition types
foreach (ConditionType error in
type.GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
.Where(field => typeof(ConditionType).IsAssignableFrom(field.FieldType))
.Select(field =>
{
ConditionType error = (ConditionType)field.GetValue(null);
if (error != null && error.Code == null)
{
error.Code = field.DeclaringType.Name + "." + field.Name;
}
return(error);
}))
{
}
}
return(rules);
}
// Обработка HTTP исключений
protected void Application_Error(object sender, EventArgs e)
{
var httpContext = ((MvcApplication)sender).Context;
var currentController = " ";
var currentAction = " ";
var currentRouteData = RouteTable.Routes.GetRouteData(new HttpContextWrapper(httpContext));
if (currentRouteData != null)
{
if (currentRouteData.Values["controller"] != null && !String.IsNullOrEmpty(currentRouteData.Values["controller"].ToString()))
{
currentController = currentRouteData.Values["controller"].ToString();
}
if (currentRouteData.Values["action"] != null && !String.IsNullOrEmpty(currentRouteData.Values["action"].ToString()))
{
currentAction = currentRouteData.Values["action"].ToString();
}
}
var ex = Server.GetLastError();
var controller = new ErrorController();
var routeData = new RouteData();
var action = "Error";
if (ex is HttpException)
{
var httpEx = ex as HttpException;
switch (httpEx.GetHttpCode())
{
case 400:
action = "BadRequest";
break;
case 404:
action = "NotFound";
break;
// и т.д.
}
}
var stackTrace = new StackTrace(ex, true);
var frames = stackTrace.GetFrames();
var source = frames != null?frames.FirstOrDefault() : null;
var declaringType = source != null?source.GetMethod().DeclaringType : this.GetType();
var logger = LogManager.GetLogger(declaringType.FullName);
logger.ErrorException(ex.Message, ex);
httpContext.ClearError();
httpContext.Response.Clear();
httpContext.Response.StatusCode = ex is HttpException ? ((HttpException)ex).GetHttpCode() : 500;
Response.Headers.Add("Content-Type", "text/html");
httpContext.Response.TrySkipIisCustomErrors = true;
routeData.Values["controller"] = "Error";
routeData.Values["action"] = action;
controller.ViewData.Model = new HandleErrorInfo(ex, currentController, currentAction);
((IController)controller).Execute(new RequestContext(new HttpContextWrapper(httpContext), routeData));
}
protected void GVCLIENTESUGERIDO_RowUpdating(object sender, GridViewUpdateEventArgs e)
{
String IdCliente = Convert.ToString(GVCLIENTESUGERIDO.DataKeys[e.RowIndex].Values["IdCliente"].ToString());
GridViewRow row = GVCLIENTESUGERIDO.Rows[e.RowIndex];
TextBox TxtMonto = row.FindControl("TxtMonto") as TextBox;
if (TxtMonto.Text == "")
{
String mensajeScript = @"<script type='text/javascript'>
swal({
title: ""Ingrese Monto"",
icon: ""warning"",
dangerMode: false,
})
</script>";
ScriptManager.RegisterStartupScript(this, typeof(Page), "mensaje", mensajeScript, false);
TxtMonto.Focus();
return;
}
String Msj = "";
try
{
Msj = obj.ModificarClienteSugerido(IdCliente, Double.Parse(TxtMonto.Text.ToString().Replace(".", ",")),
Convert.ToInt32(Request.Cookies["WebNestle"]["DLIdUsuario"]));
}
catch (Exception ex)
{
StackTrace st = new StackTrace(ex, true);
StackFrame frame = st.GetFrames().Where(f => !String.IsNullOrEmpty(f.GetFileName()) &&
f.GetILOffset() != StackFrame.OFFSET_UNKNOWN &&
f.GetNativeOffset() != StackFrame.OFFSET_UNKNOWN &&
!f.GetMethod().Module.Assembly.GetName().Name.Contains("mscorlib")).First();
string MachineName = System.Environment.MachineName;
string UserName = System.Environment.UserName.ToUpper();
string Mensaje = ex.Message;
StringBuilder builder = new StringBuilder(Mensaje);
builder.Replace("'", "");
int LineaError = frame.GetFileLineNumber();
string Proyecto = frame.GetMethod().Module.Assembly.GetName().Name;
string Clase = frame.GetMethod().DeclaringType.Name;
string metodo = frame.GetMethod().Name;
String M = "Formato Incorrecto";
string menssajeScript = "<script type='text/javascript'>"
+ " swal({" +
"title: '" + M.ToString() + "'," +
" icon: 'warning'," +
" dangerMode: false," +
" }) </script>";
ScriptManager.RegisterStartupScript(this, typeof(Page), "mensaje", menssajeScript, false);
return;
}
if (Msj != "")
{
string menssajeScript = "<script type='text/javascript'>"
+ " swal({" +
"title: '" + Msj.ToString() + "'," +
" icon: 'success'," +
" dangerMode: false," +
" }) </script>";
ScriptManager.RegisterStartupScript(this, typeof(Page), "mensaje", menssajeScript, false);
}
GVCLIENTESUGERIDO.EditIndex = -1;
ListarClienteSugerido();
}
/// <summary>
/// Utility method providing a culture invariant stack trace string.
/// </summary>
/// <remarks>
/// Since <see cref="Exception.StackTrace"/> will translate certains
/// words depending on the UI culture, an invariant version is required.
/// The implementation is actually taken from the MS reference code, without
/// the culture dependent features.
/// </remarks>
/// <returns>Culture invariant stack trace string</returns>
private string GetInvariantStackTrace()
{
#if NETSTANDARD1_1
// required classes were introduced with .NET Standard 2.0
return(exception.StackTrace);
#else
var stackTrace = new StackTrace(exception, true);
var stackFrames = stackTrace.GetFrames();
if (stackFrames == null || stackFrames.Length == 0)
{
return(string.Empty);
}
var displayFilenames = true; // we'll try, but demand may fail
var firstFrame = true;
var stackTraceBuilder = new StringBuilder();
foreach (var stackFrame in stackFrames)
{
// ensure the current frame has a method
var method = stackFrame.GetMethod();
if (method == null)
{
continue;
}
// append a newline for every stack frame, except the first one
if (firstFrame)
{
firstFrame = false;
}
else
{
stackTraceBuilder.Append(NewLine);
}
// prefix for stack frame
stackTraceBuilder.Append(StackFramePrefix);
// append type name + method name
var type = method.DeclaringType;
if (type != null)
{
stackTraceBuilder.Append(type.FullName.Replace('+', '.')).Append('.');
}
stackTraceBuilder.Append(method.Name);
// deal with the generic portion of the method
if (method is MethodInfo methodInfo && methodInfo.IsGenericMethod)
{
stackTraceBuilder.Append("[");
var genericArguments = methodInfo.GetGenericArguments();
var firstGenericArgument = true;
foreach (var genericArgument in genericArguments)
{
if (!firstGenericArgument)
{
stackTraceBuilder.Append(",");
}
else
{
firstGenericArgument = false;
}
stackTraceBuilder.Append(genericArgument.Name);
}
stackTraceBuilder.Append("]");
}
// append method arguments
stackTraceBuilder.Append("(");
var parameters = method.GetParameters();
var firstParameter = true;
foreach (var parameter in parameters)
{
if (!firstParameter)
{
stackTraceBuilder.Append(", ");
}
else
{
firstParameter = false;
}
stackTraceBuilder.Append(parameter.ParameterType?.Name ?? "<UnknownType>")
.Append(" ")
.Append(parameter.Name);
}
stackTraceBuilder.Append(")");
// check if we can add a location
if (!displayFilenames || stackFrame.GetILOffset() == -1)
{
// don't display filename - continue with next frame
continue;
}
string filename = null;
try
{
filename = stackFrame.GetFileName();
}
catch (Exception)
{
// 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"
stackTraceBuilder.Append(' ');
stackTraceBuilder.AppendFormat(CultureInfo.InvariantCulture, InFileLineNum, filename, stackFrame.GetFileLineNumber());
}
}
return(stackTraceBuilder.ToString());
#endif // !NETSTANDARD1_1
}
/// <summary>
/// Single point logoff
/// </summary>
/// <param name="urlToRedirect">
/// The URL to redirect.
/// </param>
/// <param name="removeLogin">
/// if set to <c>true</c> [remove login].
/// </param>
/// <remarks>
/// </remarks>
public static void SignOut(string urlToRedirect, bool removeLogin)
{
var st = new StackTrace(new StackFrame(1, true));
var frames = st.GetFrames();
if (frames != null)
{
var stackString = frames.Aggregate(string.Empty, (current, frame) => current + ("> " + frame.GetMethod().Name));
ErrorHandler.Publish(LogLevel.Info, "Hago signout: " + stackString);
}
// Log User Off from Cookie Authentication System
FormsAuthentication.SignOut();
// Invalidate roles token
var hck = HttpContext.Current.Response.Cookies["portalroles"];
if (hck != null)
{
hck.Value = null;
hck.Expires = new DateTime(1999, 10, 12);
hck.Path = "/";
}
if (removeLogin)
{
// Obtain PortalSettings from Current Context
var PortalSettings = (PortalSettings)HttpContext.Current.Items[StringsPortalSettings];
// Invalidate Portal Alias Cookie security
var xhck = HttpContext.Current.Response.Cookies["Appleseed_" + PortalSettings.PortalAlias.ToLower()];
if (xhck != null)
{
xhck.Value = null;
xhck.Expires = new DateTime(1999, 10, 12);
xhck.Path = "/";
}
}
// [START] [email protected] remove user window information
// User Information
// valid user
if (HttpContext.Current.User != null)
{
// Obtain PortalSettings from Current Context
// Ender 4 July 2003: Added to support the Monitoring module by Paul Yarrow
var PortalSettings = (PortalSettings)HttpContext.Current.Items[StringsPortalSettings];
// User Information
var users = new UsersDB();
MembershipUser user = users.GetSingleUser(
HttpContext.Current.User.Identity.Name, PortalSettings.PortalAlias);
if (user != null && user.ProviderUserKey != null)
{
// get user id
var uid = (Guid)user.ProviderUserKey;
if (!uid.Equals(Guid.Empty))
{
try
{
if (Config.EnableMonitoring)
{
Monitoring.LogEntry(uid, PortalSettings.PortalID, -1, "Logoff", string.Empty);
}
}
catch
{
}
}
}
}
// [END ] [email protected] remove user window information
// Redirect user back to the Portal Home Page
if (urlToRedirect.Length > 0)
{
HttpContext.Current.Response.Redirect(urlToRedirect);
}
}
public static void PrintExceptionData(object exceptionObj, bool writeToFile = false)
{
if (exceptionObj == null)
{
return;
}
Type actualType = exceptionObj.GetType();
Exception exceptionObject = exceptionObj as Exception;
var s = new StackTrace(exceptionObject);
var thisasm = Assembly.GetExecutingAssembly();
var methodName = s.GetFrames().Select(f => f.GetMethod()).First(m => m.Module.Assembly == thisasm).Name;
var parameterInfo = s.GetFrames().Select(f => f.GetMethod()).First(m => m.Module.Assembly == thisasm).GetParameters();
var methodReturnType = s.GetFrame(1).GetMethod().GetType();
var lineNumber = s.GetFrame(0).GetFileLineNumber();
// string formatedMethodNameAndParameters = $"{methodReturnType} {methodName}(";
string formatedMethodNameAndParameters = $"{methodName}(";
if (parameterInfo.Length < 1)
{
formatedMethodNameAndParameters += ")";
}
else
{
for (int n = 0; n < parameterInfo.Length; n++)
{
ParameterInfo param = parameterInfo[n];
string parameterName = param.Name;
if (n == parameterInfo.Length - 1)
{
formatedMethodNameAndParameters += $"{param.ParameterType} {parameterName})";
}
else
{
formatedMethodNameAndParameters += $"{param.ParameterType} {parameterName},";
}
}
}
string formattedContent = $"[UNHANDLED_EXCEPTION] Caught Exception of type {actualType}\n\n" +
$"Exception Message: {exceptionObject.Message}\n" +
$"Exception Origin File/Module: {exceptionObject.Source}\n" +
$"Method that threw the Exception: {formatedMethodNameAndParameters}\n";
Console.WriteLine(formattedContent);
if (exceptionObject.Data.Count > 0)
{
Console.WriteLine($"Exception Data Dictionary Results:");
foreach (DictionaryEntry pair in exceptionObject.Data)
{
Console.WriteLine(" * {0} = {1}", pair.Key, pair.Value);
}
}
if (writeToFile)
{
WriteToFile(formattedContent);
}
}
public async Task WriteException(Exception e)
{
StackTrace stackTrace = new StackTrace(e, true);
await WriteException($"{stackTrace.GetFrames().ElementAt(0).GetMethod().DeclaringType?.Name} at {stackTrace.GetFrames().ElementAt(0).GetMethod().DeclaringType?.DeclaringType?.Name}", e);
}
private string FilterStackTrace(StackTrace t)
{
StackFrame[] frames = t.GetFrames();
StringBuilder sb = new StringBuilder();
foreach(StackFrame f in frames) {
try {
string fileName = f.GetFileName();
// Filter out UnityTest itself...
if(fileName.EndsWith("UnityTest.cs")) continue;
// Shorten filenames down to the salient bits. Would use
// Application.dataPath, BUUUT that approach doesn't help unless we're
// running in the editor.
fileName = fileName.Replace(AssetDirectory, "");
// Add output in roughly the standard stack trace format:
// at Class.Method(Params) in FileName:line LineNum
// TODO: Make this follow Unity conventions.
sb
.Append("\tat ").Append(f.GetMethod().ToString()
.Replace("System.", "")).Append(" in ")
.Append(fileName).Append(":line ").Append(f.GetFileLineNumber())
.Append("\n");
} catch(NullReferenceException) {
// GetFileName can throw an NRE. Presumably from generates code that
// has no corresponding file?
}
}
return sb.ToString();
}
