public override string ToString()
{
return(String.Format(
"{0} (0x{1:x}) {2} {3}\n{4}",
GetType(), HResult, Message, InnerException == null ? "" : InnerException.ToString(),
StackTrace != null ? StackTrace : ""));
}
public override string ToString()
{
string s = GetType().ToString() + ": " + Message;
if (_fileName != null && _fileName.Length != 0)
{
s += Environment.NewLine + SR.Format(SR.IO_FileName_Name, _fileName);
}
if (InnerException != null)
{
s = s + InnerExceptionPrefix + InnerException.ToString();
}
if (StackTrace != null)
{
s += Environment.NewLine + StackTrace;
}
if (_fusionLog != null)
{
s ??= " ";
s += Environment.NewLine;
s += Environment.NewLine;
s += _fusionLog;
}
return(s);
}
public object Clone()
{
var retEx = new LogException()
{
ErrorCode = this.ErrorCode,
ExceptionType = this.ExceptionType,
HelpLink = this.HelpLink,
Message = this.Message,
Source = this.Source,
StackTrace = this.StackTrace,
TargetSite = this.TargetSite
};
if (InnerException != null)
{
retEx.InnerException = (LogException)InnerException.Clone();
}
if (Data != null && Data.Count > 0)
{
foreach (var item in Data)
{
retEx.Data.Add(item.Clone() as Property);
}
}
if (Properties != null && Properties.Count > 0)
{
foreach (var prop in Properties)
{
retEx.Properties.Add(prop.Clone() as Property);
}
}
return(retEx);
}
public void ExecuteAsync()
{
var executor = ServiceProvider.GetRequiredService <IBackgroundJobExecuter>();
Should.Throw <ScorpioException>(() => executor.ExecuteAsync(new JobExecutionContext(ServiceProvider, typeof(BackgroundJob <int>), 1)));
Should.Throw <ScorpioException>(() => executor.ExecuteAsync(new JobExecutionContext(ServiceProvider, typeof(IServiceProvider), 1)));
Should.NotThrow(async() =>
{
await executor.ExecuteAsync(new JobExecutionContext(ServiceProvider, typeof(BackgroundJob <string>), "Test"));
ServiceProvider.GetRequiredService <BackgroundJob <string> >().ReceivedWithAnyArgs(1).Execute(Arg.Any <string>());
});
Should.NotThrow(async() =>
{
await executor.ExecuteAsync(new JobExecutionContext(ServiceProvider, typeof(AsyncBackgroundJob <string>), "Test"));
await ServiceProvider.GetRequiredService <AsyncBackgroundJob <string> >().ReceivedWithAnyArgs(1).ExecuteAsync(Arg.Any <string>());
});
Should.Throw <BackgroundJobExecutionException>(async() =>
{
var job = ServiceProvider.GetRequiredService <BackgroundJob <string> >();
#pragma warning disable S3626 // Jump statements should not be redundant
job.WhenForAnyArgs(e => e.Execute(Arg.Any <string>())).Do(x => throw new NotImplementedException());
#pragma warning restore S3626 // Jump statements should not be redundant
await executor.ExecuteAsync(new JobExecutionContext(ServiceProvider, typeof(BackgroundJob <string>), "Test"));
}).InnerException.ShouldBeOfType <TargetInvocationException>().InnerException.ShouldBeOfType <NotImplementedException>();
}
/// <summary>
/// Generates an exception depending on the code of the error.
/// </summary>
/// <returns>An exception which can be thrown.</returns>
public Exception GetException()
{
Exception exception;
switch (Code)
{
/* Argument-Errors */
case 0x30000010:
exception = new ArgumentNullException(Message, InnerException?.GetException());
break;
case 0x30000011:
exception = new ArgumentException(Message, InnerException?.GetException());
break;
case 0x30000012:
exception = new ArgumentNullException(Data["PropertyName"], Message);
break;
/* Query-Errors */
case 0x30000030:
exception = new ConstraintException(Message, InnerException?.GetException());
break;
case 0x30000031:
/* PasswordUpdate-Errors */
case 0x000000A0:
exception = new ObjectNotFoundException(Message, InnerException?.GetException());
break;
/* Security-Errors */
case 0x30000070:
case 0x30000071:
case 0x30000072:
exception = new SecurityException(Message, InnerException?.GetException());
break;
/* Login-Errors */
case 0x30000080:
exception = new InvalidCredentialException(Message, InnerException?.GetException());
break;
/* Registration-Errors */
case 0x30000090:
exception = new ArgumentException(Message, InnerException?.GetException());
break;
default:
exception = new Exception(Message, InnerException?.GetException());
break;
}
foreach (KeyValuePair <string, string> entry in Data)
{
exception.Data.Add(entry.Key, entry.Value);
}
exception.Data.Add("ErrorCode", Code);
return(exception);
}
public override string ToString()
{
string s = GetType().ToString() + ": " + Message;
if (!string.IsNullOrEmpty(FileName))
{
s += Environment.NewLineConst + SR.Format(SR.IO_FileName_Name, FileName);
}
if (InnerException != null)
{
s += Environment.NewLineConst + InnerExceptionPrefix + InnerException.ToString();
}
if (StackTrace != null)
{
s += Environment.NewLineConst + StackTrace;
}
if (FusionLog != null)
{
s ??= " ";
s += Environment.NewLineConst + Environment.NewLineConst + FusionLog;
}
return(s);
}
/// <summary>
/// Creates and returns a string representation of the current <see cref="EDBTransactionBusyException"/>.
/// </summary>
/// <returns>A string representation of the current <see cref="EDBTransactionBusyException"/>.</returns>
/// <remarks>See https://msdn.microsoft.com/en-us/library/system.exception.tostring(v=vs.100).aspx for the standard
/// .NET implementation of the System.Exception.ToString() Method.</remarks>
public override string ToString()
{
string ReturnValue;
string StackTraceStr;
// Start the ToString() return value as .NET does for the System.Exception.ToString() Method...
ReturnValue = GetType().FullName + ": " + Message + Environment.NewLine;
// ...then add our "special information"...
if (NestedTransactionProblemDetails != null)
{
ReturnValue += " --> " + NestedTransactionProblemDetails + Environment.NewLine;
}
// ...and end the ToString() return value as .NET does for the System.Exception.ToString() Method.
if (InnerException != null)
{
ReturnValue += InnerException.ToString() + Environment.NewLine;
}
StackTraceStr = Environment.StackTrace;
if (!String.IsNullOrEmpty(StackTraceStr))
{
ReturnValue += "Server stack trace:" + Environment.StackTrace + Environment.NewLine;
}
return(ReturnValue);
}
public override string ToString()
{
string s = GetType().ToString() + ": " + Message;
if (FileName != null && FileName.Length != 0)
{
s += Environment.NewLine + SR.Format(SR.IO_FileName_Name, FileName);
}
if (InnerException != null)
{
s = s + " ---> " + InnerException.ToString();
}
if (StackTrace != null)
{
s += Environment.NewLine + StackTrace;
}
if (FusionLog != null)
{
if (s == null)
{
s = " ";
}
s += Environment.NewLine;
s += Environment.NewLine;
s += FusionLog;
}
return(s);
}
public override String ToString()
{
String s = GetType().FullName + ": " + Message;
if (_fileName != null && _fileName.Length != 0)
s += Environment.NewLine + Environment.GetResourceString("IO.FileName_Name", _fileName);
if (InnerException != null)
s = s + " ---> " + InnerException.ToString();
if (StackTrace != null)
s += Environment.NewLine + StackTrace;
#if FEATURE_FUSION
try
{
if(FusionLog!=null)
{
if (s==null)
s=" ";
s+=Environment.NewLine;
s+=Environment.NewLine;
s+=FusionLog;
}
}
catch(SecurityException)
{
}
#endif // FEATURE_FUSION
return s;
}
public string ToString(FileNameType fileNameType = FileNameType.Relative, bool printStackTrace = false)
{
string fileName = fileNameType == FileNameType.None
? ""
: fileNameType == FileNameType.Full
? CodeFile.FullName
: fileNameType == FileNameType.Relative
? CodeFile.RelativeName
: CodeFile.Name;
string fileNameString = !string.IsNullOrEmpty(fileName)
? $@" in ""{fileName}"""
: "";
string patternString = CodeFile.IsPattern ? "Pattern " : "";
string exceptionString = printStackTrace
? InnerException?.FormatExceptionMessage() ?? Message
: Message;
if (string.IsNullOrEmpty(exceptionString))
{
exceptionString = InnerException?.FormatExceptionMessage();
}
if (!string.IsNullOrEmpty(exceptionString))
{
exceptionString = $": {exceptionString}";
}
return($"{patternString}{ExceptionType}{fileNameString}{exceptionString}.");
}
/// <inheritdoc/>
public override string ToString()
{
string s = GetType().FullName + ": " + Message;
if (_columnName != null && _columnName.Length != 0)
{
s += Environment.NewLine + "ColumnName: " + _columnName;
if (!string.IsNullOrWhiteSpace(_tableName))
{
s += Environment.NewLine + "TableName: " + _tableName;
}
}
if (InnerException != null)
{
s = s + " ---> " + InnerException.ToString();
}
if (StackTrace != null)
{
s += Environment.NewLine + StackTrace;
}
return(s);
}
//************************************************************************
/// <summary>
/// メッセージ文字列を返す。
/// </summary>
//************************************************************************
public override string ToString()
{
if (ApplicationMessage != null)
{
// 全メッセージ文字列を連結
StringBuilder builder = new StringBuilder(ApplicationMessage.ToString());
// メッセージがエラー以外の場合は簡略化する
if (ApplicationMessage.MessageCd.Length >= 1 && ApplicationMessage.MessageCd[0] != 'E')
{
if (InnerException != null)
{
builder.AppendLine().Append(InnerException.GetType().FullName)
.Append(": ").Append(InnerException.Message);
}
}
else
{
builder.AppendLine().Append(base.ToString());
}
return(builder.ToString());
}
else
{
return(base.ToString());
}
}
/// <summary>
/// Returns a string representation of the exception
/// </summary>
/// <returns>The exception as a string</returns>
// Revision History
// MM/DD/YY who Version Issue# Description
// -------- --- ------- ------ ---------------------------------------
// 02/06/12 RCG 2.70.64 N/A Created
public override string ToString()
{
string ExceptionString = this.GetType().ToString() + ": ";
if (Message != null)
{
ExceptionString += Message + " ";
}
if (m_ExceptionResponse != null)
{
ExceptionString += "Exception Response. Service Error: " + EnumDescriptionRetriever.RetrieveDescription(m_ExceptionResponse.ServiceError)
+ " Stat Error: " + EnumDescriptionRetriever.RetrieveDescription(m_ExceptionResponse.StateError) + "\r\n";
}
if (m_ConfirmedServiceError != null)
{
ExceptionString += "Confirmed Service Error: " + m_ConfirmedServiceError.ServiceError.ToDescription();
}
if (InnerException != null)
{
ExceptionString += "Inner Exception: " + InnerException.ToString() + "\r\n";
}
ExceptionString += "Stack Trace: " + StackTrace;
return(ExceptionString);
}
public override string ToString()
{
if (null != InnerException)
{
return(InnerException.ToString());
}
return(base.ToString());
}
public override string ToString()
{
if (this.TwitterErrorCode.HasValue)
{
return(this.TwitterErrorCode.Value + ": " + Message);
}
return(InnerException.ToString());
}
/// <summary>
/// Initializes a new instance of the <see cref="aceGeneralException"/> class.
/// </summary>
/// <param name="__message">The message.</param>
/// <param name="__innerException">The inner exception.</param>
public aceGeneralException(String __message = "", Exception __innerException = null, Object __callerInstane = null, String __title = "", Int32 stacks = 0) : base(__message, __innerException)
{
Int32 stackSkip = 1 + stacks;
while (__innerException != null)
{
__innerException = __innerException.InnerException as aceGeneralException;
stackSkip++;
}
_stackTrace = new StackTrace(true);
//_stackFrame = _stackTrace.GetFrame(0);
_stackFrame = getFirstFrameWithSource(_stackTrace, stackSkip);
_message = __message;
title = __title;
if (_stackTrace == null)
{
_stackTraceText = Environment.StackTrace;
}
else
{
_stackTraceText = _stackTrace.ToString();
}
callInfo = callerInfo.getCallerInfo(_stackFrame, true);
info = callInfo.AppendDataFields(info);
info = callInfo.AppendDataFieldsOfMethod(info);
if (InnerException != null)
{
if (imbSciStringExtensions.isNullOrEmptyString(__message))
{
_message += Environment.NewLine + InnerException.Message;
}
if (imbSciStringExtensions.isNullOrEmptyString(title))
{
title = "Exception: " + InnerException.GetType().Name + " in " + callInfo.className;
}
}
var ex = InnerException;
imbSCI.Core.reporting.render.builders.builderForMarkdown md = new builderForMarkdown();
Int32 c = 1;
while (ex != null)
{
ex.reportSummary(md, "Inner exception [" + c + "]");
ex = ex.InnerException;
c++;
}
_message = _message.addLine(md.ContentToString());
HelpLink = Directory.GetCurrentDirectory() + "\\diagnostics\\index.html";
}
private XElement GetXElement()
=> new XElement
(
"Exception",
new XElement(nameof(Message), Message),
new XElement(nameof(Source), Source),
new XElement(nameof(Helplink), Helplink),
new XElement(nameof(StackTrace), StackTrace),
InnerException?.GetXElement()
);
public void FilterFactoryThrows()
{
_filterFactories[0] = provider => throw new NotSupportedException("oops!");
var ex = Assert.Throws <InvalidOperationException>(() => _sut.CreateHandler(_service.Object, _context.Object));
Console.WriteLine(ex);
ex !.InnerException.ShouldBeOfType <NotSupportedException>();
ex.InnerException.Message.ShouldContain("oops!");
}
/// <summary>
/// Puke original exception (only with Message, HelpLink and Source properties, other properties are has not accessible
/// setters) with inner exceptions
/// </summary>
/// <returns>Exception</returns>
public Exception PukeException()
{
var exception = InnerException != null
? new Exception(Message, InnerException.PukeException())
: new Exception(Message);
exception.HelpLink = HelpLink;
exception.Source = Source;
return(exception);
}
public override string ToString()
{
if (InnerException != null)
{
return(InnerException.ToString());
}
else
{
return(String.Format("Line: [{0}] Query: " + Query, Line));
}
}
public override string ToString()
{
return(string.Format(@"{0}
{1}
{2}
innerException:
{3}
{2}
server Exception:
{4}", base.Message, StackTrace, new string('-', 80), InnerException?.OutlineException(), serverException));
}
/// <summary>
/// Gibt einen <see cref="T:System.String"/> zurück, der das aktuelle <see cref="T:System.Object"/> darstellt.
/// </summary>
/// <returns>
/// Ein <see cref="T:System.String"/>, der das aktuelle <see cref="T:System.Object"/> darstellt.
/// </returns>
/// <filterpriority>2</filterpriority>
public override string ToString()
{
return($@"{ExceptionType}: {Message}
{StackTrace}
Exception-Data:
{string.Join(@"
", from t in collectedInformation select $"{t.Key}: {t.Value}")}
{new string('-', 80)}
{((InnerException != null) ? string.Join($@"
{new string('-', 80)}", InnerException?.Select(n => n.ToString()) ?? new string[] {""}) : "")}");
}
public override string ToString()
{
string text = $"{Message}\r\nContent:\r\n\t\t{Content.Replace("\r\n", "\r\n\t\t\t")}\r\n\r\n";
if (InnerException != null)
{
return(text + "Inner Exception:\r\n" + InnerException.ToString().Replace("\r\n", "\r\n\t\t\t"));
}
return(text);
}
/// <summary>
/// Creates and returns a string representation of the current exception.
/// </summary>
/// <returns>
/// A string representation of the current exception.
/// </returns>
public override string ToString()
{
StringBuilder builder = new StringBuilder(base.ToString());
if (InnerException != null)
{
builder.AppendLine(string.Format("Inner Exception ({0}): ", InnerException.GetType()));
builder.AppendLine(InnerException.ToString());
}
return(builder.ToString());
}
/// <summary>
/// Obtém os detalhes do erro em formato string
/// </summary>
/// <param name="ex"></param>
/// <returns></returns>
public override string ToString()
{
var exMsg = (Message != null) ? "MESSAGE = " + Message.ToString() : string.Empty;
var exInner = (InnerException != null) ? " | INNER: " + InnerException.ToString() : string.Empty;
var exStack = (StackTrace != null) ? " | STACK: " + StackTrace.ToString() : string.Empty;
var exSource = (StackTrace != null) ? " | SOURCE: " + Source.ToString() : string.Empty;
var msg = string.Format("[ {0} {1} {3} {2} ]", exMsg, exInner, exStack, exSource);
return(msg);
}
public override string ToString()
{
string ret = "<Exception exceptionCode='" + ExceptionCode
+ (!string.IsNullOrEmpty(Locator) ? "' locator='" + Locator : "")
+ (!string.IsNullOrEmpty(Message) ? "'><ExceptionText>" + Utils.FormatStringForXml(Message) + "</ExceptionText>\n</Exception>" : "'/>");
if (InnerException != null)
{
ret = InnerException.ToString() + "\n" + ret;
}
return(ret);
}
public override int GetHashCode()
{
unchecked
{
var hashCode = Type.GetHashCode();
hashCode = (hashCode * 397) ^ Message.GetHashCode();
hashCode = (hashCode * 397) ^ StackTrace.GetHashCode();
hashCode = (hashCode * 397) ^ (InnerException != null ? InnerException.GetHashCode() : 0);
return(hashCode);
}
}
/// <summary>
/// Checks for specific error types
/// </summary>
/// <param name="exceptionTypes">the desired types</param>
/// <returns>a value indicating whether the specified type was found</returns>
public bool ContainsType(params string[] exceptionTypes)
{
bool retVal =
exceptionTypes.Select(
t => ExceptionType != null && ExceptionType.Contains(t)).Any(n => n);
if (!retVal && InnerException != null)
{
retVal |= InnerException.Any(n => n.ContainsType(exceptionTypes));
}
return(retVal);
}
public override string ToString()
{
string output = type.ToString();
if (Message != "")
{
output += "\n" + Message;
}
if (InnerException != null)
{
output += "\n" + InnerException.ToString();
}
return(output);
}
public override string ToString()
{
var sb = new StringBuilder();
sb.AppendFormat("DbCommandExecutionException: {0}\r\ninnerException:\r\n{1}\r\ndatabase: {2}\r\ncommandTimeout: {3}\r\ncommandText: {4}",
Message,
InnerException.ToLogString(),
_database,
_commandTimeout,
_commandText);
var s = sb.ToString();
return(s);
}
