static public void WriteLine(CeTraceLevel ahtl, Type atype, String asMethod, Exception aexception, String asMessage)
{
// I18N OK <ccla>
WriteLineBare(ahtl, "Exception in " + Format(atype, asMethod) +
": " + aexception.GetType().Name + ": " + aexception.Message +
(asMessage == null ? String.Empty : ": \"" + asMessage + "\""));
}
static public void WriteCallerHeader(CeTraceLevel ahmtracelevel, int aiLevel)
{
WriteDividerLine(ahmtracelevel);
WriteTimeStampLine(ahmtracelevel);
WriteCaller(ahmtracelevel, aiLevel - 1);
WriteDividerLine(ahmtracelevel);
}
/// <summary>
/// Write stack data about the caller to trace listeners. Use passed
/// level to control what is considered the caller. Use 0 for the method
/// that immediately called this one, subtracting 1 for each method higher
/// up the call stack.
/// </summary>
static public void WriteCaller(CeTraceLevel ahmtracelevel, int aiLevel)
{
StackLevel asl = StackLevel.FromEnvironment(5 - aiLevel);
WriteLineBare(ahmtracelevel, asl.CallingMethod);
WriteBare(ahmtracelevel, asl.SourcePath);
WriteBare(ahmtracelevel, " ");
WriteLineBare(ahmtracelevel, asl.LineNumber);
}
static public void WriteLoadedModules(CeTraceLevel ahtl)
{
StringWriter asw = new StringWriter(CultureInfo.InvariantCulture);
ResourceProcessLibrary.ListLoadedModules(asw);
WriteDividerLine(ahtl);
WriteBare(ahtl, asw.ToString());
WriteDividerLine(ahtl);
}
static public void WriteLine(CeTraceLevel ahtl, Type atype, String asMethod, String asMessage)
{
// return early to avoid unnecessary string operations
if (!ShouldTrace(ahtl))
{
return;
}
WriteLineBare(
ahtl,
Format(atype, asMethod) + (asMessage == null ? "" : ": " + asMessage));
}
static public void WriteTimeStampLine(CeTraceLevel ahmtracelevel, String astring)
{
#if TIMESTAMP_ALL_LINES
String astringLine = ResourceStringLibrary.IsBlank(astring) ? String.Empty : astring;
#else
String astringLine = FormatDateTimeNow();
if (!StringLibrary.IsBlank(astring))
{
astringLine = astringLine + " " + astring;
}
#endif
WriteLineBare(ahmtracelevel, astringLine);
}
static private void WriteLineBare(CeTraceLevel alevel, String astring)
{
// return early to avoid unnecessary string operations
if (!ShouldTrace(alevel))
{
return;
}
#if TIMESTAMP_ALL_LINES
String astringLine = astring; // I18N OK <ccla>
#else
String astringLine = astring;
#endif
Trace.WriteLine(astringLine);
}
static public void WriteLine(CeTraceLevel ahtl, Object aobject, String asMethod, DataRow adr)
{
// return early to avoid unnecessary string operations
if (!ShouldTrace(ahtl))
{
return;
}
// I18N OK <ccla>
WriteLine(ahtl, aobject, asMethod, adr.ToString());
WriteBare(ahtl, "\t");
WriteBare(ahtl, "HasErrors: " + adr.HasErrors);
WriteBare(ahtl, " HasVersion(Current): " + adr.HasVersion(DataRowVersion.Current));
WriteBare(ahtl, " HasVersion(Default): " + adr.HasVersion(DataRowVersion.Default));
WriteBare(ahtl, " HasVersion(Original): " + adr.HasVersion(DataRowVersion.Original));
WriteBare(ahtl, " HasVersion(Proposed): " + adr.HasVersion(DataRowVersion.Proposed));
WriteBare(ahtl, " RowError: \"" + adr.RowError + "\"");
WriteBare(ahtl, " RowState: " + adr.RowState);
WriteLineBare(ahtl, "");
}
static public void WriteLine(CeTraceLevel ahtl, Object aobject, String asMethod, OleDbException aode)
{
// return early to avoid unnecessary string operations
if (!ShouldTrace(ahtl))
{
return;
}
WriteLine(ahtl, aobject, asMethod, (Exception)aode); // Cast is critical to avoid recursion and stack overflow!
foreach (OleDbError aerror in aode.Errors)
{
// I18N OK <ccla>
WriteBare(ahtl, "\t");
WriteBare(ahtl, "Message: " + aerror.Message);
WriteBare(ahtl, " Native: " + aerror.NativeError);
WriteBare(ahtl, " Source: " + aerror.Source);
WriteBare(ahtl, " SQL: " + aerror.SQLState);
WriteLineBare(ahtl, "");
}
}
static public void WriteLine(CeTraceLevel ahtl, Object aobject, String asMethod, Exception aexception)
{
WriteLine(ahtl, aobject, asMethod, aexception, null);
}
static public void WriteLine(CeTraceLevel ahtl, Object aobject, String asMethod, String asMessage)
{
WriteLine(ahtl, aobject.GetType(), asMethod, asMessage);
}
static public void WriteLine(CeTraceLevel ahtl, Object aobject, String asMethod)
{
WriteLine(ahtl, aobject, asMethod, (String)null);
}
static public void WriteEmptyLine(CeTraceLevel ahmtracelevel)
{
WriteLineBare(ahmtracelevel, String.Empty);
}
static public void WriteDividerLine(CeTraceLevel ahmtracelevel)
{
WriteLineBare(ahmtracelevel, new String('=', 80));
}
static public void WriteTimeStampLine(CeTraceLevel ahmtracelevel)
{
WriteTimeStampLine(ahmtracelevel, null);
}
/// <summary>
/// WARNING: Use this method very sparingly, because it does not require
/// logging the originating class/method, which will make understanding
/// the trace much more difficult.
/// </summary>
static public void WriteLine(CeTraceLevel ahtl, String astring)
{
WriteLineBare(ahtl, astring);
}
static public void WriteLine(CeTraceLevel ahtl, Type atype, String asMethod, Exception aexception)
{
WriteLine(ahtl, atype, asMethod, aexception, null);
}
static private void WriteBare(CeTraceLevel alevel, String astring)
{
Trace.WriteIf(ShouldTrace(alevel), astring);
}
static private bool ShouldTrace(CeTraceLevel alevel)
{
return(alevel != CeTraceLevel.Off && alevel <= CurrentTraceLevel);
}
