< Summary

Information
Class: System.Net.NetEventSource
Assembly: System.Net.WebSockets
File(s): File 1: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/System/Net/Logging/NetEventSource.Common.Associate.cs
File 2: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/System/Net/Logging/NetEventSource.Common.cs
File 3: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/NetEventSource.WebSockets.cs
Line coverage
0%
Covered lines: 1
Uncovered lines: 176
Coverable lines: 177
Total lines: 579
Line coverage: 0.5%
Branch coverage
0%
Covered branches: 0
Total branches: 62
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
File 1: Associate(...)100%110%
File 1: Associate(...)100%110%
File 1: Associate(...)0%220%
File 1: WriteEvent(...)0%16160%
File 2: .cctor()100%11100%
File 2: IdOf(...)0%220%
File 2: GetHashCode(...)0%220%
File 2: WriteEvent(...)0%880%
File 3: KeepAliveSent(...)100%110%
File 3: KeepAliveAcked(...)100%110%
File 3: KeepAlivePingSent(...)100%110%
File 3: PongResponseReceived(...)100%110%
File 3: WsTrace(...)100%110%
File 3: TraceErrorMsg(...)100%110%
File 3: TraceException(...)100%110%
File 3: Trace(...)0%660%
File 3: CloseStart(...)100%110%
File 3: CloseStop(...)100%110%
File 3: CloseAsyncPrivateStarted(...)0%220%
File 3: CloseAsyncPrivateCompleted(...)0%220%
File 3: ReceiveStart(...)100%110%
File 3: ReceiveStop(...)100%110%
File 3: ReceiveAsyncPrivateStarted(...)0%220%
File 3: ReceiveAsyncPrivateCompleted(...)0%220%
File 3: SendStart(...)100%110%
File 3: SendStop(...)100%110%
File 3: SendFrameAsyncStarted(...)0%220%
File 3: SendFrameAsyncCompleted(...)0%220%
File 3: MutexEnter(...)100%110%
File 3: MutexExit(...)100%110%
File 3: MutexEntered(...)0%220%
File 3: MutexExited(...)0%220%
File 3: WriteEvent(...)0%440%
File 3: WriteEvent(...)0%660%

File(s)

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/System/Net/Logging/NetEventSource.Common.Associate.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Diagnostics;
 5using System.Diagnostics.CodeAnalysis;
 6using System.Diagnostics.Tracing;
 7using System.Runtime.CompilerServices;
 8
 9namespace System.Net
 10{
 11    internal sealed partial class NetEventSource
 12    {
 13        private const int AssociateEventId = 3;
 14
 15        /// <summary>Logs a relationship between two objects.</summary>
 16        /// <param name="first">The first object.</param>
 17        /// <param name="second">The second object.</param>
 18        /// <param name="memberName">The calling member.</param>
 19        [NonEvent]
 20        public static void Associate(object first, object second, [CallerMemberName] string? memberName = null) =>
 021            Associate(first, first, second, memberName);
 22
 23        /// <summary>Logs a relationship between two objects.</summary>
 24        /// <param name="thisOrContextObject">`this`, or another object that serves to provide context for the operation
 25        /// <param name="first">The first object.</param>
 26        /// <param name="second">The second object.</param>
 27        /// <param name="memberName">The calling member.</param>
 28        [NonEvent]
 29        public static void Associate(object? thisOrContextObject, object first, object second, [CallerMemberName] string
 030            Log.Associate(IdOf(thisOrContextObject), memberName, IdOf(first), IdOf(second));
 31
 32        [Event(AssociateEventId, Level = EventLevel.Informational, Message = "[{2}]<-->[{3}]")]
 33        private void Associate(string thisOrContextObject, string? memberName, string first, string second)
 034        {
 035            Debug.Assert(IsEnabled());
 036            WriteEvent(AssociateEventId, thisOrContextObject, memberName ?? MissingMember, first, second);
 037        }
 38
 39        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",
 40                   Justification = EventSourceSuppressMessage)]
 41        [NonEvent]
 42        private unsafe void WriteEvent(int eventId, string? arg1, string? arg2, string? arg3, string? arg4)
 043        {
 044            arg1 ??= "";
 045            arg2 ??= "";
 046            arg3 ??= "";
 047            arg4 ??= "";
 48
 049            fixed (char* string1Bytes = arg1)
 050            fixed (char* string2Bytes = arg2)
 051            fixed (char* string3Bytes = arg3)
 052            fixed (char* string4Bytes = arg4)
 053            {
 54                const int NumEventDatas = 4;
 055                EventData* descrs = stackalloc EventData[NumEventDatas];
 56
 057                descrs[0] = new EventData
 058                {
 059                    DataPointer = (IntPtr)string1Bytes,
 060                    Size = ((arg1.Length + 1) * 2)
 061                };
 062                descrs[1] = new EventData
 063                {
 064                    DataPointer = (IntPtr)string2Bytes,
 065                    Size = ((arg2.Length + 1) * 2)
 066                };
 067                descrs[2] = new EventData
 068                {
 069                    DataPointer = (IntPtr)string3Bytes,
 070                    Size = ((arg3.Length + 1) * 2)
 071                };
 072                descrs[3] = new EventData
 073                {
 074                    DataPointer = (IntPtr)string4Bytes,
 075                    Size = ((arg4.Length + 1) * 2)
 076                };
 77
 078                WriteEventCore(eventId, NumEventDatas, descrs);
 079            }
 080        }
 81    }
 82}
 83

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/System/Net/Logging/NetEventSource.Common.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Collections;
 5using System.Diagnostics;
 6using System.Diagnostics.CodeAnalysis;
 7using System.Diagnostics.Tracing;
 8using System.Runtime.CompilerServices;
 9using System.Runtime.InteropServices;
 10
 11#pragma warning disable CA1823 // not all IDs are used by all partial providers
 12
 13namespace System.Net
 14{
 15    // Implementation:
 16    // This partial file is meant to be consumed into each System.Net.* assembly that needs to log.  Each such assembly 
 17    // its own NetEventSource partial class that adds an appropriate [EventSource] attribute, giving it a unique name fo
 18    // Those partials can then also add additional events if needed, starting numbering from the NextAvailableEventId de
 19
 20    // Usage:
 21    // - Operations that may allocate (e.g. boxing a value type, using string interpolation, etc.) or that may have comp
 22    //   at call sites should guard access like:
 23    //       if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(null, $"Found certificate: {cert}"); // info loggin
 24    // - Operations that have zero allocations / measurable computations at call sites can use a simpler pattern, callin
 25    //       NetEventSource.Info(this, "literal string");  // arbitrary message with a literal string
 26    //   Debug.Asserts inside the logging methods will help to flag some misuse if the DEBUG_NETEVENTSOURCE_MISUSE compi
 27    //   However, because it can be difficult by observation to understand all of the costs involved, guarding can be do
 28    // - Messages can be strings, formattable strings, or any other object.  Objects (including those used in formattabl
 29    //   formatting applied, controlled by the Format method.  Partial specializations can also override this formatting
 30    //   method that takes an object and optionally provides a string representation of it, in case a particular library
 31
 32    /// <summary>Provides logging facilities for System.Net libraries.</summary>
 33    internal sealed partial class NetEventSource : EventSource
 34    {
 35        private const string EventSourceSuppressMessage = "Parameters to this method are primitive and are trimmer safe"
 36
 37        /// <summary>The single event source instance to use for all logging.</summary>
 138        public static readonly NetEventSource Log = new NetEventSource();
 39
 40        #region Metadata
 41        private const string MissingMember = "(?)";
 42        private const string NullInstance = "(null)";
 43        private const string StaticMethodObject = "(static)";
 44        private const string NoParameters = "";
 45
 46        private const int InfoEventId = 1;
 47        private const int ErrorEventId = 2;
 48        // private const int AssociateEventId = 3; // Defined in NetEventSource.Common.Associate.cs
 49        // private const int DumpArrayEventId = 4; // Defined in NetEventSource.Common.DumpBuffer.cs
 50
 51        private const int NextAvailableEventId = 5; // Update this value whenever new events are added.  Derived types s
 52        #endregion
 53
 54        #region Info
 55        /// <summary>Logs an information message.</summary>
 56        /// <param name="thisOrContextObject">`this`, or another object that serves to provide context for the operation
 57        /// <param name="formattableString">The message to be logged.</param>
 58        /// <param name="memberName">The calling member.</param>
 59        [NonEvent]
 60        public static void Info(object? thisOrContextObject, FormattableString? formattableString = null, [CallerMemberN
 61            Log.Info(IdOf(thisOrContextObject), memberName, formattableString != null ? Format(formattableString) : NoPa
 62
 63        /// <summary>Logs an information message.</summary>
 64        /// <param name="thisOrContextObject">`this`, or another object that serves to provide context for the operation
 65        /// <param name="message">The message to be logged.</param>
 66        /// <param name="memberName">The calling member.</param>
 67        [NonEvent]
 68        public static void Info(object? thisOrContextObject, object? message, [CallerMemberName] string? memberName = nu
 69            Log.Info(IdOf(thisOrContextObject), memberName, Format(message));
 70
 71        [Event(InfoEventId, Level = EventLevel.Informational)]
 72        private void Info(string thisOrContextObject, string? memberName, string? message)
 73        {
 74            Debug.Assert(IsEnabled());
 75            WriteEvent(InfoEventId, thisOrContextObject, memberName ?? MissingMember, message);
 76        }
 77        #endregion
 78
 79        #region Error
 80        /// <summary>Logs an error message.</summary>
 81        /// <param name="thisOrContextObject">`this`, or another object that serves to provide context for the operation
 82        /// <param name="formattableString">The message to be logged.</param>
 83        /// <param name="memberName">The calling member.</param>
 84        [NonEvent]
 85        public static void Error(object? thisOrContextObject, FormattableString formattableString, [CallerMemberName] st
 86            Log.ErrorMessage(IdOf(thisOrContextObject), memberName, Format(formattableString));
 87
 88        /// <summary>Logs an error message.</summary>
 89        /// <param name="thisOrContextObject">`this`, or another object that serves to provide context for the operation
 90        /// <param name="message">The message to be logged.</param>
 91        /// <param name="memberName">The calling member.</param>
 92        [NonEvent]
 93        public static void Error(object? thisOrContextObject, object message, [CallerMemberName] string? memberName = nu
 94            Log.ErrorMessage(IdOf(thisOrContextObject), memberName, Format(message));
 95
 96        [Event(ErrorEventId, Level = EventLevel.Error)]
 97        private void ErrorMessage(string thisOrContextObject, string? memberName, string? message)
 98        {
 99            Debug.Assert(IsEnabled());
 100            WriteEvent(ErrorEventId, thisOrContextObject, memberName ?? MissingMember, message);
 101        }
 102        #endregion
 103
 104        #region Helpers
 105        [NonEvent]
 0106        public static string IdOf(object? value) => value != null ? value.GetType().Name + "#" + GetHashCode(value) : Nu
 107
 108        [NonEvent]
 0109        public static int GetHashCode(object? value) => value?.GetHashCode() ?? 0;
 110
 111        [NonEvent]
 112        public static string? Format(object? value)
 113        {
 114            // If it's null, return a known string for null values
 115            if (value == null)
 116            {
 117                return NullInstance;
 118            }
 119
 120            // Give another partial implementation a chance to provide its own string representation
 121            string? result = null;
 122            AdditionalCustomizedToString(value, ref result);
 123            if (result is not null)
 124            {
 125                return result;
 126            }
 127
 128            // Format arrays with their element type name and length
 129            if (value is Array arr)
 130            {
 131                return $"{arr.GetType().GetElementType()}[{((Array)value).Length}]";
 132            }
 133
 134            // Format ICollections as the name and count
 135            if (value is ICollection c)
 136            {
 137                return $"{c.GetType().Name}({c.Count})";
 138            }
 139
 140            // Format SafeHandles as their type, hash code, and pointer value
 141            if (value is SafeHandle handle)
 142            {
 143                return $"{handle.GetType().Name}:{handle.GetHashCode()}(0x{handle.DangerousGetHandle():X})";
 144            }
 145
 146            // Format IntPtrs as hex
 147            if (value is IntPtr)
 148            {
 149                return $"0x{value:X}";
 150            }
 151
 152            // If the string representation of the instance would just be its type name,
 153            // use its id instead.
 154            string? toString = value.ToString();
 155            if (toString == null || toString == value.GetType().FullName)
 156            {
 157                return IdOf(value);
 158            }
 159
 160            // Otherwise, return the original object so that the caller does default formatting.
 161            return value.ToString();
 162        }
 163
 164        [NonEvent]
 165        private static string Format(FormattableString s)
 166        {
 167            switch (s.ArgumentCount)
 168            {
 169                case 0: return s.Format;
 170                case 1: return string.Format(s.Format, Format(s.GetArgument(0)));
 171                case 2: return string.Format(s.Format, Format(s.GetArgument(0)), Format(s.GetArgument(1)));
 172                case 3: return string.Format(s.Format, Format(s.GetArgument(0)), Format(s.GetArgument(1)), Format(s.GetA
 173                default:
 174                    string?[] formattedArgs = new string?[s.ArgumentCount];
 175                    for (int i = 0; i < formattedArgs.Length; i++)
 176                    {
 177                        formattedArgs[i] = Format(s.GetArgument(i));
 178                    }
 179                    return string.Format(s.Format, formattedArgs);
 180            }
 181        }
 182
 183        static partial void AdditionalCustomizedToString(object value, ref string? result);
 184        #endregion
 185
 186        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",
 187                   Justification = EventSourceSuppressMessage)]
 188        [NonEvent]
 189        private unsafe void WriteEvent(int eventId, string? arg1, string? arg2, int arg3)
 0190        {
 0191            arg1 ??= "";
 0192            arg2 ??= "";
 193
 0194            fixed (char* arg1Ptr = arg1)
 0195            fixed (char* arg2Ptr = arg2)
 0196            {
 197                const int NumEventDatas = 3;
 0198                EventData* descrs = stackalloc EventData[NumEventDatas];
 199
 0200                descrs[0] = new EventData
 0201                {
 0202                    DataPointer = (IntPtr)(arg1Ptr),
 0203                    Size = (arg1.Length + 1) * sizeof(char)
 0204                };
 0205                descrs[1] = new EventData
 0206                {
 0207                    DataPointer = (IntPtr)(arg2Ptr),
 0208                    Size = (arg2.Length + 1) * sizeof(char)
 0209                };
 0210                descrs[2] = new EventData
 0211                {
 0212                    DataPointer = (IntPtr)(&arg3),
 0213                    Size = sizeof(int)
 0214                };
 215
 0216                WriteEventCore(eventId, NumEventDatas, descrs);
 0217            }
 0218        }
 219    }
 220}
 221

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/System.Net.WebSockets/src/System/Net/WebSockets/NetEventSource.WebSockets.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.Diagnostics;
 5using System.Diagnostics.CodeAnalysis;
 6using System.Diagnostics.Tracing;
 7using System.Runtime.CompilerServices;
 8
 9namespace System.Net
 10{
 11    [EventSource(Name = "Private.InternalDiagnostics.System.Net.WebSockets")]
 12    internal sealed partial class NetEventSource
 13    {
 14        // NOTE
 15        // - The 'Start' and 'Stop' suffixes on the following event names have special meaning in EventSource. They
 16        //   enable creating 'activities'.
 17        //   For more information, take a look at the following blog post:
 18        //   https://blogs.msdn.microsoft.com/vancem/2015/09/14/exploring-eventsource-activity-correlation-and-causation
 19        // - A stop event's event id must be next one after its start event.
 20
 21        private const int KeepAliveSentId = NextAvailableEventId;
 22        private const int KeepAliveAckedId = KeepAliveSentId + 1;
 23
 24        private const int WsTraceId = KeepAliveAckedId + 1;
 25
 26        private const int CloseStartId = WsTraceId + 1;
 27        private const int CloseStopId = CloseStartId + 1;
 28
 29        private const int ReceiveStartId = CloseStopId + 1;
 30        private const int ReceiveStopId = ReceiveStartId + 1;
 31
 32        private const int SendStartId = ReceiveStopId + 1;
 33        private const int SendStopId = SendStartId + 1;
 34
 35        private const int MutexEnterId = SendStopId + 1;
 36        private const int MutexExitId = MutexEnterId + 1;
 37
 38        //
 39        // Keep-Alive
 40        //
 41
 42        private const string Ping = "Ping";
 43        private const string Pong = "Pong";
 44
 45        [Event(KeepAliveSentId, Level = EventLevel.Informational)]
 46        private void KeepAliveSent(string objName, string opcode, long payload) =>
 047            WriteEvent(KeepAliveSentId, objName, opcode, payload);
 48
 49        [Event(KeepAliveAckedId, Level = EventLevel.Informational)]
 50        private void KeepAliveAcked(string objName, long payload) =>
 051            WriteEvent(KeepAliveAckedId, objName, payload);
 52
 53        [NonEvent]
 54        public static void KeepAlivePingSent(object? obj, long payload)
 055        {
 056            Debug.Assert(Log.IsEnabled());
 057            Log.KeepAliveSent(IdOf(obj), Ping, payload);
 058        }
 59
 60        [NonEvent]
 61        public static void UnsolicitedPongSent(object? obj)
 62        {
 63            Debug.Assert(Log.IsEnabled());
 64            Log.KeepAliveSent(IdOf(obj), Pong, 0);
 65        }
 66
 67        [NonEvent]
 68        public static void PongResponseReceived(object? obj, long payload)
 069        {
 070            Debug.Assert(Log.IsEnabled());
 071            Log.KeepAliveAcked(IdOf(obj), payload);
 072        }
 73
 74        //
 75        // Debug Messages
 76        //
 77
 78        [Event(WsTraceId, Level = EventLevel.Verbose)]
 79        private void WsTrace(string objName, string memberName, string message) =>
 080            WriteEvent(WsTraceId, objName, memberName, message);
 81
 82        [NonEvent]
 83        public static void TraceErrorMsg(object? obj, Exception exception, [CallerMemberName] string? memberName = null)
 084            => Trace(obj, $"{exception.GetType().Name}: {exception.Message}", memberName);
 85
 86        [NonEvent]
 87        public static void TraceException(object? obj, Exception exception, [CallerMemberName] string? memberName = null
 088            => Trace(obj, exception.ToString(), memberName);
 89
 90        [NonEvent]
 91        public static void Trace(object? obj, string? message = null, [CallerMemberName] string? memberName = null)
 092        {
 093            Debug.Assert(Log.IsEnabled());
 094            Log.WsTrace(IdOf(obj), memberName ?? MissingMember, message ?? memberName ?? string.Empty);
 095        }
 96
 97        //
 98        // Close
 99        //
 100
 101        [Event(CloseStartId, Level = EventLevel.Verbose)]
 102        private void CloseStart(string objName, string memberName) =>
 0103            WriteEvent(CloseStartId, objName, memberName);
 104
 105        [Event(CloseStopId, Level = EventLevel.Verbose)]
 106        private void CloseStop(string objName, string memberName) =>
 0107            WriteEvent(CloseStopId, objName, memberName);
 108
 109        [NonEvent]
 110        public static void CloseAsyncPrivateStarted(object? obj, [CallerMemberName] string? memberName = null)
 0111        {
 0112            Debug.Assert(Log.IsEnabled());
 0113            Log.CloseStart(IdOf(obj), memberName ?? MissingMember);
 0114        }
 115
 116        [NonEvent]
 117        public static void CloseAsyncPrivateCompleted(object? obj, [CallerMemberName] string? memberName = null)
 0118        {
 0119            Debug.Assert(Log.IsEnabled());
 0120            Log.CloseStop(IdOf(obj), memberName ?? MissingMember);
 0121        }
 122
 123        //
 124        // ReceiveAsyncPrivate
 125        //
 126
 127        [Event(ReceiveStartId, Level = EventLevel.Informational)]
 128        private void ReceiveStart(string objName, string memberName, int bufferLength) =>
 0129            WriteEvent(ReceiveStartId, objName, memberName, bufferLength);
 130
 131        [Event(ReceiveStopId, Level = EventLevel.Informational)]
 132        private void ReceiveStop(string objName, string memberName) =>
 0133            WriteEvent(ReceiveStopId, objName, memberName);
 134
 135        [NonEvent]
 136        public static void ReceiveAsyncPrivateStarted(object? obj, int bufferLength, [CallerMemberName] string? memberNa
 0137        {
 0138            Debug.Assert(Log.IsEnabled());
 0139            Log.ReceiveStart(IdOf(obj), memberName ?? MissingMember, bufferLength);
 0140        }
 141
 142        [NonEvent]
 143        public static void ReceiveAsyncPrivateCompleted(object? obj, [CallerMemberName] string? memberName = null)
 0144        {
 0145            Debug.Assert(Log.IsEnabled());
 0146            Log.ReceiveStop(IdOf(obj), memberName ?? MissingMember);
 0147        }
 148
 149        //
 150        // SendFrameAsync
 151        //
 152
 153        [Event(SendStartId, Level = EventLevel.Verbose)]
 154        private void SendStart(string objName, string memberName, string opcode, int bufferLength) =>
 0155            WriteEvent(SendStartId, objName, memberName, opcode, bufferLength);
 156
 157        [Event(SendStopId, Level = EventLevel.Verbose)]
 158        private void SendStop(string objName, string memberName) =>
 0159            WriteEvent(SendStopId, objName, memberName);
 160
 161        [NonEvent]
 162        public static void SendFrameAsyncStarted(object? obj, string opcode, int bufferLength, [CallerMemberName] string
 0163        {
 0164            Debug.Assert(Log.IsEnabled());
 0165            Log.SendStart(IdOf(obj), memberName ?? MissingMember, opcode, bufferLength);
 0166        }
 167
 168        [NonEvent]
 169        public static void SendFrameAsyncCompleted(object? obj, [CallerMemberName] string? memberName = null)
 0170        {
 0171            Debug.Assert(Log.IsEnabled());
 0172            Log.SendStop(IdOf(obj), memberName ?? MissingMember);
 0173        }
 174
 175        //
 176        // AsyncMutex
 177        //
 178
 179        [Event(MutexEnterId, Level = EventLevel.Verbose)]
 180        private void MutexEnter(string objName, string memberName) =>
 0181            WriteEvent(MutexEnterId, objName, memberName);
 182
 183        [Event(MutexExitId, Level = EventLevel.Verbose)]
 184        private void MutexExit(string objName, string memberName) =>
 0185            WriteEvent(MutexExitId, objName, memberName);
 186
 187        [NonEvent]
 188        public static void MutexEntered(object? obj, [CallerMemberName] string? memberName = null)
 0189        {
 0190            Debug.Assert(Log.IsEnabled());
 0191            Log.MutexEnter(IdOf(obj), memberName ?? MissingMember);
 0192        }
 193
 194        [NonEvent]
 195        public static void MutexExited(object? obj, [CallerMemberName] string? memberName = null)
 0196        {
 0197            Debug.Assert(Log.IsEnabled());
 0198            Log.MutexExit(IdOf(obj), memberName ?? MissingMember);
 0199        }
 200
 201        //
 202        // WriteEvent overloads
 203        //
 204
 205        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",
 206                   Justification = EventSourceSuppressMessage)]
 207        [NonEvent]
 208        private unsafe void WriteEvent(int eventId, string arg1, string arg2, long arg3)
 0209        {
 0210            fixed (char* arg1Ptr = arg1)
 0211            fixed (char* arg2Ptr = arg2)
 0212            {
 213                const int NumEventDatas = 3;
 0214                EventData* descrs = stackalloc EventData[NumEventDatas];
 215
 0216                descrs[0] = new EventData
 0217                {
 0218                    DataPointer = (IntPtr)(arg1Ptr),
 0219                    Size = (arg1.Length + 1) * sizeof(char)
 0220                };
 0221                descrs[1] = new EventData
 0222                {
 0223                    DataPointer = (IntPtr)(arg2Ptr),
 0224                    Size = (arg2.Length + 1) * sizeof(char)
 0225                };
 0226                descrs[2] = new EventData
 0227                {
 0228                    DataPointer = (IntPtr)(&arg3),
 0229                    Size = sizeof(long)
 0230                };
 231
 0232                WriteEventCore(eventId, NumEventDatas, descrs);
 0233            }
 0234        }
 235
 236        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026:UnrecognizedReflectionPattern",
 237                   Justification = EventSourceSuppressMessage)]
 238        [NonEvent]
 239        private unsafe void WriteEvent(int eventId, string arg1, string arg2, string arg3, int arg4)
 0240        {
 0241            fixed (char* arg1Ptr = arg1)
 0242            fixed (char* arg2Ptr = arg2)
 0243            fixed (char* arg3Ptr = arg3)
 0244            {
 245                const int NumEventDatas = 4;
 0246                EventData* descrs = stackalloc EventData[NumEventDatas];
 247
 0248                descrs[0] = new EventData
 0249                {
 0250                    DataPointer = (IntPtr)(arg1Ptr),
 0251                    Size = (arg1.Length + 1) * sizeof(char)
 0252                };
 0253                descrs[1] = new EventData
 0254                {
 0255                    DataPointer = (IntPtr)(arg2Ptr),
 0256                    Size = (arg2.Length + 1) * sizeof(char)
 0257                };
 0258                descrs[2] = new EventData
 0259                {
 0260                    DataPointer = (IntPtr)(arg3Ptr),
 0261                    Size = (arg3.Length + 1) * sizeof(char)
 0262                };
 0263                descrs[3] = new EventData
 0264                {
 0265                    DataPointer = (IntPtr)(&arg4),
 0266                    Size = sizeof(int)
 0267                };
 268
 0269                WriteEventCore(eventId, NumEventDatas, descrs);
 0270            }
 0271        }
 272
 273    }
 274}
 275
Generated by: ReportGenerator 5.5.11.0
10/9/2026 - 6:52:32 PM
GitHub | reportgenerator.io

Methods/Properties

Associate(System.Object,System.Object,System.String)
Associate(System.Object,System.Object,System.Object,System.String)
Associate(System.String,System.String,System.String,System.String)
WriteEvent(System.Int32,System.String,System.String,System.String,System.String)
.cctor()
IdOf(System.Object)
GetHashCode(System.Object)
WriteEvent(System.Int32,System.String,System.String,System.Int32)
KeepAliveSent(System.String,System.String,System.Int64)
KeepAliveAcked(System.String,System.Int64)
KeepAlivePingSent(System.Object,System.Int64)
PongResponseReceived(System.Object,System.Int64)
WsTrace(System.String,System.String,System.String)
TraceErrorMsg(System.Object,System.Exception,System.String)
TraceException(System.Object,System.Exception,System.String)
Trace(System.Object,System.String,System.String)
CloseStart(System.String,System.String)
CloseStop(System.String,System.String)
CloseAsyncPrivateStarted(System.Object,System.String)
CloseAsyncPrivateCompleted(System.Object,System.String)
ReceiveStart(System.String,System.String,System.Int32)
ReceiveStop(System.String,System.String)
ReceiveAsyncPrivateStarted(System.Object,System.Int32,System.String)
ReceiveAsyncPrivateCompleted(System.Object,System.String)
SendStart(System.String,System.String,System.String,System.Int32)
SendStop(System.String,System.String)
SendFrameAsyncStarted(System.Object,System.String,System.Int32,System.String)
SendFrameAsyncCompleted(System.Object,System.String)
MutexEnter(System.String,System.String)
MutexExit(System.String,System.String)
MutexEntered(System.Object,System.String)
MutexExited(System.Object,System.String)
WriteEvent(System.Int32,System.String,System.String,System.Int64)
WriteEvent(System.Int32,System.String,System.String,System.String,System.Int32)