public static void PrepareListenerData(RITraceListenerData tData, TraceEventType eventType)
{
switch (eventType)
{
case TraceEventType.Information: tData.MessageType = MessageType.SendInformation; break;
case TraceEventType.Warning: tData.MessageType = MessageType.SendWarning; break;
case TraceEventType.Error: tData.MessageType = MessageType.SendError; break;
case TraceEventType.Critical: tData.MessageType = MessageType.SendFatal; break;
case TraceEventType.Start: tData.MessageType = MessageType.SendStart; break;
case TraceEventType.Stop: tData.MessageType = MessageType.SendStop; break;
case TraceEventType.Suspend: tData.MessageType = MessageType.SendSuspend; break;
case TraceEventType.Resume: tData.MessageType = MessageType.SendResume; break;
case TraceEventType.Transfer: tData.MessageType = MessageType.SendTransfer; break;
case TraceEventType.Verbose: tData.MessageType = MessageType.SendVerbose; break;
default:
// safety net catch in case a new or unknown TraceEventType was added in future releases of .NET
tData.MessageType = MessageType.SendMessage;
tData.Message = String.Format("[{0}]: {1}", eventType, tData.Message);
break;
}
}
public override void WriteLine(String msg)
{
RITraceListenerData tData = new RITraceListenerData()
{
MessageType = MessageType.SendMessage, Message = msg
};
TraceData(null, null, TraceEventType.Information, 0, tData);
}
public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
{
RITraceListenerData tData = new RITraceListenerData()
{
Message = message
};
PrepareListenerData(tData, eventType);
TraceData(null, null, TraceEventType.Information, 0, tData);
}
public override void TraceData(TraceEventCache eventCache, string source, TraceEventType eventType, int id, object data)
{
ActiveStates states = CurrentActiveStates;
if (data is RITraceListenerData)
{
RITraceListenerData tData = data as RITraceListenerData;
try
{
// ignore complex message types as they are not
// allowed for simple message types
if (tData.MessageType >= RIUtils.ComplexMessageTypeStartRange)
{
return;
}
// amend extended properties to RI message if any
if (tData.ExtendedProperties != null && tData.ExtendedProperties.Count > 0)
{
StringBuilder sb = tData.Details == null ? new StringBuilder() : null;
if (sb != null)
{
sb.AppendLine("Extended Properties");
sb.AppendLine("-------------------");
}
foreach (String key in tData.ExtendedProperties.Keys)
{
String value = tData.ExtendedProperties[key] != null ? tData.ExtendedProperties[key].ToString() : String.Empty;
RIExtendedMessageProperty.AttachToSingleMessage("Extended Properties", key, value);
if (sb != null)
{
sb.AppendFormat("{0}: {1}{2}", key, value, Environment.NewLine);
}
}
if (sb != null)
{
tData.Details = sb.ToString();
}
}
if (tData.Message.StartsWith("[Enter]"))
{
states.RI.EnterMethod(tData.Message.Replace("[Enter]", String.Empty).Trim());
return;
}
else if (tData.Message.StartsWith("[Exit]"))
{
states.RI.ExitMethod(tData.Message.Replace("[Exit]", String.Empty).Trim());
return;
}
TrackIndent();
try
{
states.RI.Send(tData.MessageType, GetFullWriteMessage(tData.Message), tData.Details == null ? null : tData.Details.ToString());
}
finally
{
TrackIndent();
}
}
catch (Exception ex)
{
if (!SendInternalError(states.RI, tData.MessageType, ex))
{
throw;
}
}
}
else
{
TraceEvent(eventCache, source, eventType, id, data.ToString());
}
}
