/// <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);