public void TraceWithFilters()
        {
            string log    = "TraceWithFilters";
            string source = "Source" + nameof(TraceEventFormatAndParams);

            try
            {
                EventLog.CreateEventSource(source, log);
                using (var listener = new EventLogTraceListener(source))
                {
                    listener.Filter = new EventTypeFilter(SourceLevels.Critical);
                    listener.TraceData(null, source, TraceEventType.Information, 12, "string shouldn't be present");
                    EventLogEntry eventLogEntry = listener.EventLog.Entries.LastOrDefault();
                    if (eventLogEntry != null)
                    {
                        Assert.DoesNotContain("string shouldn't be present", eventLogEntry.Message);
                    }

                    listener.TraceData(null, source, TraceEventType.Information, 12, "string shouldn't be present", "neither should this");
                    eventLogEntry = listener.EventLog.Entries.LastOrDefault();
                    if (eventLogEntry != null)
                    {
                        Assert.DoesNotContain("string shouldn't be present", eventLogEntry.Message);
                        Assert.DoesNotContain("neither should this", eventLogEntry.Message);
                    }

                    listener.TraceEvent(null, source, TraceEventType.Information, 12, "trace an event casually", "one more", null);
                    eventLogEntry = listener.EventLog.Entries.LastOrDefault();
                    if (eventLogEntry != null)
                    {
                        Assert.DoesNotContain("trace an event casually", eventLogEntry.Message);
                        Assert.DoesNotContain("one more", eventLogEntry.Message);
                    }

                    listener.TraceEvent(null, source, TraceEventType.Information, 12, "i shouldn't be here");
                    eventLogEntry = listener.EventLog.Entries.LastOrDefault();
                    if (eventLogEntry != null)
                    {
                        Assert.DoesNotContain("i shouldn't be here", eventLogEntry.Message);
                    }
                }
            }
            finally
            {
                EventLog.DeleteEventSource(source);
                Helpers.RetryOnWin7(() => EventLog.Delete(log));
            }
        }
        public void TraceEventTest(TraceEventType eventType, EventLogEntryType expectedType, int id, int expectedId)
        {
            string log    = "TraceEvent";
            string source = "Source" + nameof(TraceEventTest);

            try
            {
                EventLog.CreateEventSource(source, log);
                using (var listener = new EventLogTraceListener(source))
                {
                    string message = "One simple message to trace";
                    listener.TraceEvent(null, source, eventType, id, message);
                    EventLogEntry eventLogEntry = ValidateLastEntryMessage(listener, message, source);

                    if (eventLogEntry != null)
                    {
                        Assert.Equal(expectedType, eventLogEntry.EntryType);
                        Assert.Equal(expectedId, eventLogEntry.InstanceId);
                    }
                }
            }
            finally
            {
                EventLog.DeleteEventSource(source);
                Helpers.RetryOnWin7(() => EventLog.Delete(log));
            }
        }
 public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
 {
     foreach (var splitMessage in SplitMessage(message))
     {
         _listener.TraceEvent(eventCache, source, eventType, id, splitMessage);
     }
 }
        public void TraceEventFormatAndParams(string format, object[] parameters)
        {
            string log    = "TraceEvent";
            string source = "Source" + nameof(TraceEventFormatAndParams);

            try
            {
                EventLog.CreateEventSource(source, log);
                using (var listener = new EventLogTraceListener(source))
                {
                    listener.TraceEvent(null, source, TraceEventType.Information, 1000, format, parameters);

                    if (parameters == null || parameters.Length == 0)
                    {
                        string[] messages;
                        if (string.IsNullOrEmpty(format))
                        {
                            messages = Array.Empty <string>();
                        }
                        else
                        {
                            messages = new string[] { format }
                        };

                        EventLogEntry eventLogEntry = listener.EventLog.Entries.LastOrDefault();
                        if (eventLogEntry != null)
                        {
                            Assert.All(messages, message => eventLogEntry.Message.Contains(message));
                        }
                    }
                    else if (string.IsNullOrEmpty(format))
                    {
                        string[] messages = new string[parameters.Length];
                        for (int i = 0; i < messages.Length; i++)
                        {
                            messages[i] = parameters[i].ToString();
                        }

                        EventLogEntry eventLogEntry = listener.EventLog.Entries.LastOrDefault();
                        if (eventLogEntry != null)
                        {
                            Assert.All(messages, message => eventLogEntry.Message.Contains(message));
                        }
                    }
                    else
                    {
                        string expectedMessage = string.Format(CultureInfo.InvariantCulture, format, parameters);
                        ValidateLastEntryMessage(listener, expectedMessage, source);
                    }
                }
            }
            finally
            {
                EventLog.DeleteEventSource(source);
                Helpers.RetryOnWin7(() => EventLog.Delete(log));
            }
        }
 /// <summary>
 /// イベント情報をイベントログに書き込みます。
 /// </summary>
 /// <param name="eventCache"></param>
 /// <param name="source"></param>
 /// <param name="eventType"></param>
 /// <param name="id"></param>
 /// <param name="message"></param>
 public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
 {
     _listener.TraceEvent(eventCache, source, eventType, EventId, message);
 }