|
public static AddReadersInfo ( |
||
| exp | ||
| Результат | ||
public ErrorReporting(Exception uncaughtException)
: this(InvariantMessage(uncaughtException), InvariantStackTrace(uncaughtException))
{
try
{
if (ReferenceEquals(uncaughtException.GetType(), typeof(System.Data.SQLite.SQLiteException)))
{
// Add extra information to the exception to help debug sqlite concurrency
uncaughtException = SQLiteMonDataReader.AddReadersInfo(uncaughtException);
uncaughtException = SQLiteMonTransaction.AddTransactionsInfo(uncaughtException);
}
this.fields.Add("Exception.ToString()", uncaughtException.ToString());
// Set up a list of types which do not need to be serialized
List <Type> notSerialize = new List <Type>(new Type[]
{
typeof(string),
typeof(int),
typeof(float),
typeof(double),
typeof(bool)
});
// Store the type of the exception and get a list of its properties to loop through
Type exceptionType = uncaughtException.GetType();
PropertyInfo[] baseExceptionProperties = typeof(Exception).GetProperties();
bool extraProperty = false;
bool overloadedProp = false;
foreach (PropertyInfo thisExpProperty in exceptionType.GetProperties())
{
extraProperty = true;
overloadedProp = false;
// Check if this property exists in the base exception class: if not then add it to the report
foreach (PropertyInfo baseProperty in baseExceptionProperties)
{
if (thisExpProperty.Name == baseProperty.Name)
{
extraProperty = false;
break;
}
}
// Test to see if this property is overloaded
foreach (PropertyInfo overloadChkProp in exceptionType.GetProperties())
{
if (!overloadChkProp.Equals(thisExpProperty))
{
if (overloadChkProp.Name == thisExpProperty.Name)
{
overloadedProp = true;
break;
}
}
}
if (extraProperty)
{
string fieldName = "Exception." + thisExpProperty.Name;
object propertyValue = thisExpProperty.GetValue(uncaughtException, null);
if (overloadedProp)
{
string typeName = propertyValue.GetType().ToString();
int dotPos = typeName.LastIndexOf(".", StringComparison.Ordinal);
if (dotPos >= 0)
{
typeName = typeName.Substring(dotPos + 1);
}
fieldName += ":" + typeName;
}
if (propertyValue != null && !string.IsNullOrEmpty(propertyValue.ToString()))
{
if (propertyValue.GetType() == typeof(Provider.ErrorType))
{
// ErrorType is always set to UnknownError on DownloadExceptions
continue;
}
if (!notSerialize.Contains(propertyValue.GetType()))
{
if (propertyValue.GetType().IsSerializable)
{
// Attempt to serialize the object as an XML string
try
{
StringWriter valueStringWriter = new StringWriter(CultureInfo.InvariantCulture);
XmlSerializer valueSerializer = new XmlSerializer(propertyValue.GetType());
valueSerializer.Serialize(valueStringWriter, propertyValue);
this.fields.Add(fieldName, valueStringWriter.ToString());
continue;
}
catch (NotSupportedException)
{
// Not possible to serialize - do nothing & fall through to the ToString code
}
catch (InvalidOperationException)
{
// Problem serializing the object - do nothing & fall through to the ToString code
}
}
}
this.fields.Add(fieldName, propertyValue.ToString());
}
}
}
if (uncaughtException.Data != null)
{
foreach (DictionaryEntry dataEntry in uncaughtException.Data)
{
if (ReferenceEquals(dataEntry.Key.GetType(), typeof(string)) && ReferenceEquals(dataEntry.Value.GetType(), typeof(string)))
{
this.fields[(string)dataEntry.Key] = (string)dataEntry.Value;
}
}
}
}
catch
{
// No way of reporting errors that have happened here, so try to continue
}
}
