/// <summary>
/// Tries to send the given message to all attached listeners.
/// </summary>
/// <param name="message">The message to be sent.</param>
private static void SendMessageToListeners(DebugMessage message)
{
if(message == null) {
return;
}
// check if there is any listener attached
if(listeners == null || listeners.Count == 0) {
return;
}
if(ExcludeMessage(message)) {
return;
}
// send the message to all listeners
for(int i = 0; i < listeners.Count; i++) {
// skip disabled listeners
if(!listeners[i].Enabled) {
continue;
}
if(!listeners[i].IsOpen) {
listeners[i].Open();
}
listeners[i].DumpMessage(message);
}
}
/// <summary>
/// Shows the debug message using the attached debug message notifier.
/// </summary>
/// <param name="message">The message to be sent.</param>
private static void SendMessageToNotifier(DebugMessage message)
{
if(message == null) {
return;
}
if(DebugMessageNotifier != null && DebugMessageNotifier.Enabled) {
DebugMessageNotifier.Message = message;
if(!DebugMessageNotifier.Launch()) {
Console.WriteLine("Couldn't launch IDebugMessageNotifier {0}",
DebugMessageNotifier.GetType().Name);
}
}
}
/// <summary>
/// Allocates and initializes a message with its type and message.
/// </summary>
/// <param name="type">The type of the message.</param>
/// <param name="message">The message string.</param>
/// <returns>A <typeparamref name="DebugMessage"/> object.</returns>
private static DebugMessage InitDebugMessage(DebugMessageType type, string message)
{
DebugMessage debugMessage = new DebugMessage();
// assign current time
debugMessage.Type = type;
debugMessage.Time = DateTime.Now;
debugMessage.Color = _color;
// set context
if(contextStack.Count > 0) {
debugMessage.Context = contextStack.Peek();
}
else {
debugMessage.Context = null;
}
// set message
if(message != null) {
debugMessage.Message = message;
}
// set thread info
debugMessage.ThreadName = Thread.CurrentThread.Name;
debugMessage.ThreadId = AppDomain.GetCurrentThreadId();
return debugMessage;
}
/// <summary>
/// Allocates an empty message.
/// </summary>
/// <returns>A <typeparamref name="DebugMessage"/> object.</returns>
private static DebugMessage InitDebugMessage()
{
DebugMessage debugMessage = new DebugMessage();
debugMessage.Time = DateTime.Now;
return debugMessage;
}
/// <summary>
/// Tries to add to the message all the stack information available at the given moment.
/// </summary>
/// <param name="message">The message to which to attach the stack information.</param>
private static void AddStackInfoToMessage(DebugMessage message)
{
if(message == null) {
return;
}
// check if we need to allocate the stack segments
if(message.HasStack && message.StackSegments != null) {
message.StackSegments.Clear();
}
else {
message.StackSegments = new List<StackSegment>();
message.HasStack = true;
}
// obtain stack information
StackTrace stackInfo = new StackTrace(0, true);
for(int i = 0; i < stackInfo.FrameCount; i++) {
StackSegment segment = new StackSegment();
StackFrame frame = stackInfo.GetFrame(i);
if(frame.GetMethod().DeclaringType.Namespace == typeof(Debug).Namespace) {
continue;
}
// copy the relevant data
segment.File = frame.GetFileName();
segment.DeclaringObject = frame.GetMethod().DeclaringType.Name;
segment.DeclaringNamespace = frame.GetMethod().DeclaringType.Namespace;
segment.Method = frame.GetMethod().ToString();
AddMethodType(frame, segment);
segment.Line = frame.GetFileLineNumber();
message.StackSegments.Add(segment);
}
}
/// <summary>
/// Filter the message.
/// </summary>
/// <param name="message">The message to filter.</param>
/// <returns>
/// true if the message is allowed; false, otherwise.
/// </returns>
private static bool ExcludeMessage(DebugMessage message)
{
if(message == null) {
return true;
}
if(filters != null && filters.Count > 0) {
bool? result = null;
for(int i = 0; i < filters.Count; i++) {
if(!filters[i].Enabled) {
continue;
}
if(filters[i].Implication == MessageFilterImplication.OR) {
if(filters[i].AllowMessage(message)) {
return true;
}
}
else // AND implication
{
// combine the result
if(result.HasValue) {
result &= filters[i].AllowMessage(message);
}
else result = filters[i].AllowMessage(message);
if(result.HasValue && result.Value) {
return true;
}
}
}
if(result.HasValue) {
return result.Value;
}
else return false;
}
return false;
}
/// <summary>
/// Tries to add the stack information for the Method that generated the given message.
/// </summary>
/// <param name="message">The message to which to attach the information.</param>
private static void AddBaseMethodInfoToMessage(DebugMessage message)
{
if(message == null) {
return;
}
// obtain stack information
StackFrame frame = GetTopMethod();
if(frame != null) {
// copy the relevant data
message.BaseMethod.File = frame.GetFileName();
message.BaseMethod.DeclaringObject = frame.GetMethod().DeclaringType.Name;
message.BaseMethod.DeclaringNamespace = frame.GetMethod().DeclaringType.Namespace;
message.BaseMethod.Method = frame.GetMethod().ToString();
AddMethodType(frame, message.BaseMethod);
message.BaseMethod.Line = frame.GetFileLineNumber();
}
}
/// <summary>
/// Tries to add the given message to the list.
/// </summary>
/// <param name="message">The message to add.</param>
private static void AddMessageToStore(DebugMessage message)
{
if(message == null) {
return;
}
AssureMessageListIsAllocated();
lock(lockObject) {
if(messages.Count == _messageStoreCapacity && messages.Count != 0) {
messages.RemoveAt(0);
}
messages.Add(message);
}
}
public unsafe void SendMessage(DebugMessage message)
{
byte[] data = SerializeMessage(message);
if(data != null && data.Length > 0) {
// send message
CopyDataStruct copyData = new CopyDataStruct();
copyData.ID = IntPtr.Zero;
copyData.Length = data.Length;
fixed(byte* datePointer = data) {
copyData.Data = (IntPtr)datePointer;
SendMessage(windowHandle, WM_COPYDATA, 0, ref copyData);
}
}
}
private byte[] SerializeMessage(DebugMessage message)
{
try {
MemoryStream stream = new MemoryStream();
XmlSerializer serializer = new XmlSerializer(typeof(DebugMessage));
serializer.Serialize(stream, message);
return stream.ToArray();
}
catch {
return null;
}
}
public bool DumpMessage(DebugMessage message)
{
SendMessage(message);
return true;
}
private void ShowStack(DebugMessage message)
{
Stack.Items.Clear();
if(message.HasStack) {
foreach(StackSegment segment in message.StackSegments) {
ListViewItem item = new ListViewItem();
item.Text = segment.DeclaringObject;
item.SubItems.Add(segment.Method);
Stack.Items.Add(item);
}
}
}
private void AddMessage(DebugMessage message)
{
// filter
if(message.Type == DebugMessageType.Error && !showErrors) {
return;
}
else if(message.Type == DebugMessageType.Unknown && !showOthers) {
return;
}
else if(message.Type == DebugMessageType.Warning && !showWarnings) {
return;
}
string filterValue = textBox1.Text.Trim();
if(filterValue.Length > 0 && !message.Message.Contains(filterValue)) {
return;
}
// add
ListViewItem item = new ListViewItem();
int index = List.Items.Count + 1;
item.Tag = message;
item.Text = index.ToString();
item.SubItems.Add(message.Time.ToLongTimeString());
item.SubItems.Add(Path.GetFileName(message.BaseMethod.File));
item.SubItems.Add(message.BaseMethod.DeclaringObject);
item.SubItems.Add(message.BaseMethod.Method);
item.SubItems.Add(message.BaseMethod.Line.ToString());
item.SubItems.Add(message.Message);
if(message.Type == DebugMessageType.Error) {
item.BackColor = index % 2 == 0 ? Color.FromArgb(255, 237, 237) :
Color.FromArgb(255, 222, 222);
item.ImageIndex = 0;
}
else if(message.Type == DebugMessageType.Warning) {
item.BackColor = index % 2 == 0 ? Color.FromArgb(255, 255, 237) :
Color.FromArgb(255, 255, 222);
item.ImageIndex = 1;
}
else {
item.BackColor = index % 2 == 0 ? Color.FromArgb(237, 245, 255) :
Color.FromArgb(222, 230, 255);
item.ImageIndex = 2;
}
List.Items.Add(item);
}
public abstract bool AllowMessage(DebugMessage message);
public abstract bool DumpMessage(DebugMessage message);
