File: TD.Designer.cs

package info (click to toggle)
mono 4.6.2.7%2Bdfsg-1
links: PTS, VCS
area: main
in suites: stretch
size: 778,148 kB
ctags: 914,052
sloc: cs: 5,779,509; xml: 2,773,713; ansic: 432,645; sh: 14,749; makefile: 12,361; perl: 2,488; python: 1,434; cpp: 849; asm: 531; sql: 95; sed: 16; php: 1
file content (5420 lines) | stat: -rw-r--r-- 283,041 bytes
parent folder | download | duplicates (9)
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.ServiceModel.Diagnostics.Application
{
    using System.Runtime;
    using System.Runtime.Diagnostics;
    using System.Security;
    
    
    internal partial class TD
    {
        
        static System.Resources.ResourceManager resourceManager;
        
        static System.Globalization.CultureInfo resourceCulture;
        
        [System.Security.SecurityCriticalAttribute()]
        static System.Runtime.Diagnostics.EventDescriptor[] eventDescriptors;
        
        static object syncLock = new object();
        
        // Double-checked locking pattern requires volatile for read/write synchronization
        static volatile bool eventDescriptorsCreated;
        
        private TD()
        {
        }
        
        [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification="This is an auto-generated code, some ETW/TraceSource mixed code would use it.")]
        static System.Resources.ResourceManager ResourceManager
        {
            get
            {
                if (object.ReferenceEquals(resourceManager, null))
                {
                    resourceManager = new System.Resources.ResourceManager("System.ServiceModel.Diagnostics.Application.TD", typeof(TD).Assembly);
                }
                return resourceManager;
            }
        }
        
        [System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification="This template is shared across all assemblies, some of which use this accessor.")]
        internal static System.Globalization.CultureInfo Culture
        {
            get
            {
                return resourceCulture;
            }
            set
            {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=217, Level=informational, Channel=Debug
        /// </summary>
        internal static bool ClientOperationPreparedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(0));
        }
        
        /// <summary>
        /// Gets trace definition like: The Client is executing Action '{0}' associated with the '{1}' contract. The message will be sent to '{2}'.
        /// Event description ID=217, Level=informational, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="Action">Parameter 0 for event: The Client is executing Action '{0}' associated with the '{1}' contract. The message will be sent to '{2}'.</param>
        /// <param name="ContractName">Parameter 1 for event: The Client is executing Action '{0}' associated with the '{1}' contract. The message will be sent to '{2}'.</param>
        /// <param name="Destination">Parameter 2 for event: The Client is executing Action '{0}' associated with the '{1}' contract. The message will be sent to '{2}'.</param>
        /// <param name="relatedActivityId">The related event activity Id</param>
        internal static void ClientOperationPrepared(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string Action, string ContractName, string Destination, System.Guid relatedActivityId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(0))
            {
                TD.WriteEtwTransferEvent(0, eventTraceActivity, relatedActivityId, Action, ContractName, Destination, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=201, Level=informational, Channel=Debug
        /// </summary>
        internal static bool ClientMessageInspectorAfterReceiveInvokedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(1));
        }
        
        /// <summary>
        /// Gets trace definition like: The Dispatcher invoked 'AfterReceiveReply' on a ClientMessageInspector of type '{0}'.
        /// Event description ID=201, Level=informational, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="TypeName">Parameter 0 for event: The Dispatcher invoked 'AfterReceiveReply' on a ClientMessageInspector of type '{0}'.</param>
        internal static void ClientMessageInspectorAfterReceiveInvoked(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string TypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(1))
            {
                TD.WriteEtwEvent(1, eventTraceActivity, TypeName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=202, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ClientMessageInspectorBeforeSendInvokedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(2));
        }
        
        /// <summary>
        /// Gets trace definition like: The Dispatcher invoked 'BeforeSendRequest' on a ClientMessageInspector of type  '{0}'.
        /// Event description ID=202, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="TypeName">Parameter 0 for event: The Dispatcher invoked 'BeforeSendRequest' on a ClientMessageInspector of type  '{0}'.</param>
        internal static void ClientMessageInspectorBeforeSendInvoked(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string TypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(2))
            {
                TD.WriteEtwEvent(2, eventTraceActivity, TypeName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=203, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ClientParameterInspectorAfterCallInvokedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(3));
        }
        
        /// <summary>
        /// Gets trace definition like: The Dispatcher invoked 'AfterCall' on a ClientParameterInspector of type '{0}'.
        /// Event description ID=203, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="TypeName">Parameter 0 for event: The Dispatcher invoked 'AfterCall' on a ClientParameterInspector of type '{0}'.</param>
        internal static void ClientParameterInspectorAfterCallInvoked(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string TypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(3))
            {
                TD.WriteEtwEvent(3, eventTraceActivity, TypeName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=204, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ClientParameterInspectorBeforeCallInvokedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(4));
        }
        
        /// <summary>
        /// Gets trace definition like: The Dispatcher invoked 'BeforeCall' on a ClientParameterInspector of type '{0}'.
        /// Event description ID=204, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="TypeName">Parameter 0 for event: The Dispatcher invoked 'BeforeCall' on a ClientParameterInspector of type '{0}'.</param>
        internal static void ClientParameterInspectorBeforeCallInvoked(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string TypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(4))
            {
                TD.WriteEtwEvent(4, eventTraceActivity, TypeName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=205, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool OperationInvokedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(5));
        }
        
        /// <summary>
        /// Gets trace definition like: An OperationInvoker invoked the '{0}' method. Caller information: '{1}'.
        /// Event description ID=205, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="MethodName">Parameter 0 for event: An OperationInvoker invoked the '{0}' method. Caller information: '{1}'.</param>
        /// <param name="CallerInfo">Parameter 1 for event: An OperationInvoker invoked the '{0}' method. Caller information: '{1}'.</param>
        internal static void OperationInvoked(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string MethodName, string CallerInfo)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(5))
            {
                TD.WriteEtwEvent(5, eventTraceActivity, MethodName, CallerInfo, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=206, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ErrorHandlerInvokedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(6));
        }
        
        /// <summary>
        /// Gets trace definition like: The Dispatcher invoked an ErrorHandler of type  '{0}' with an exception of type '{2}'.  ErrorHandled == '{1}'.
        /// Event description ID=206, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="TypeName">Parameter 0 for event: The Dispatcher invoked an ErrorHandler of type  '{0}' with an exception of type '{2}'.  ErrorHandled == '{1}'.</param>
        /// <param name="Handled">Parameter 1 for event: The Dispatcher invoked an ErrorHandler of type  '{0}' with an exception of type '{2}'.  ErrorHandled == '{1}'.</param>
        /// <param name="ExceptionTypeName">Parameter 2 for event: The Dispatcher invoked an ErrorHandler of type  '{0}' with an exception of type '{2}'.  ErrorHandled == '{1}'.</param>
        internal static void ErrorHandlerInvoked(string TypeName, bool Handled, string ExceptionTypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(6))
            {
                TD.WriteEtwEvent(6, null, TypeName, Handled, ExceptionTypeName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=207, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool FaultProviderInvokedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(7));
        }
        
        /// <summary>
        /// Gets trace definition like: The Dispatcher invoked a FaultProvider of type '{0}' with an exception of type '{1}'.
        /// Event description ID=207, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="TypeName">Parameter 0 for event: The Dispatcher invoked a FaultProvider of type '{0}' with an exception of type '{1}'.</param>
        /// <param name="ExceptionTypeName">Parameter 1 for event: The Dispatcher invoked a FaultProvider of type '{0}' with an exception of type '{1}'.</param>
        internal static void FaultProviderInvoked(string TypeName, string ExceptionTypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(7))
            {
                TD.WriteEtwEvent(7, null, TypeName, ExceptionTypeName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=208, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool MessageInspectorAfterReceiveInvokedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(8));
        }
        
        /// <summary>
        /// Gets trace definition like: The Dispatcher invoked 'AfterReceiveReply' on a MessageInspector of type '{0}'.
        /// Event description ID=208, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="TypeName">Parameter 0 for event: The Dispatcher invoked 'AfterReceiveReply' on a MessageInspector of type '{0}'.</param>
        internal static void MessageInspectorAfterReceiveInvoked(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string TypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(8))
            {
                TD.WriteEtwEvent(8, eventTraceActivity, TypeName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=209, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool MessageInspectorBeforeSendInvokedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(9));
        }
        
        /// <summary>
        /// Gets trace definition like: The Dispatcher invoked 'BeforeSendRequest' on a MessageInspector of type '{0}'.
        /// Event description ID=209, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="TypeName">Parameter 0 for event: The Dispatcher invoked 'BeforeSendRequest' on a MessageInspector of type '{0}'.</param>
        internal static void MessageInspectorBeforeSendInvoked(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string TypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(9))
            {
                TD.WriteEtwEvent(9, eventTraceActivity, TypeName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=210, Level=Warning, Channel=Analytic
        /// </summary>
        internal static bool MessageThrottleExceededIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(10));
        }
        
        /// <summary>
        /// Gets trace definition like: The '{0}' throttle limit of '{1}' was hit.
        /// Event description ID=210, Level=Warning, Channel=Analytic
        /// </summary>
        /// <param name="ThrottleName">Parameter 0 for event: The '{0}' throttle limit of '{1}' was hit.</param>
        /// <param name="Limit">Parameter 1 for event: The '{0}' throttle limit of '{1}' was hit.</param>
        internal static void MessageThrottleExceeded(string ThrottleName, long Limit)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(10))
            {
                TD.WriteEtwEvent(10, null, ThrottleName, Limit, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=211, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ParameterInspectorAfterCallInvokedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(11));
        }
        
        /// <summary>
        /// Gets trace definition like: The Dispatcher invoked 'AfterCall' on a ParameterInspector of type '{0}'.
        /// Event description ID=211, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="TypeName">Parameter 0 for event: The Dispatcher invoked 'AfterCall' on a ParameterInspector of type '{0}'.</param>
        internal static void ParameterInspectorAfterCallInvoked(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string TypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(11))
            {
                TD.WriteEtwEvent(11, eventTraceActivity, TypeName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=212, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ParameterInspectorBeforeCallInvokedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(12));
        }
        
        /// <summary>
        /// Gets trace definition like: The Dispatcher invoked 'BeforeCall' on a ParameterInspector of type '{0}'.
        /// Event description ID=212, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="TypeName">Parameter 0 for event: The Dispatcher invoked 'BeforeCall' on a ParameterInspector of type '{0}'.</param>
        internal static void ParameterInspectorBeforeCallInvoked(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string TypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(12))
            {
                TD.WriteEtwEvent(12, eventTraceActivity, TypeName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=214, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool OperationCompletedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(13));
        }
        
        /// <summary>
        /// Gets trace definition like: An OperationInvoker completed the call to the '{0}' method.  The method call duration was '{1}' ms.
        /// Event description ID=214, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="MethodName">Parameter 0 for event: An OperationInvoker completed the call to the '{0}' method.  The method call duration was '{1}' ms.</param>
        /// <param name="Duration">Parameter 1 for event: An OperationInvoker completed the call to the '{0}' method.  The method call duration was '{1}' ms.</param>
        internal static void OperationCompleted(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string MethodName, long Duration)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(13))
            {
                TD.WriteEtwEvent(13, eventTraceActivity, MethodName, Duration, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=215, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool MessageReceivedByTransportIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(14));
        }
        
        /// <summary>
        /// Gets trace definition like: The transport received a message from '{0}'.
        /// Event description ID=215, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="ListenAddress">Parameter 0 for event: The transport received a message from '{0}'.</param>
        /// <param name="relatedActivityId">The related event activity Id</param>
        internal static void MessageReceivedByTransport(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string ListenAddress, System.Guid relatedActivityId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(14))
            {
                TD.WriteEtwTransferEvent(14, eventTraceActivity, relatedActivityId, ListenAddress, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=216, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool MessageSentByTransportIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(15));
        }
        
        /// <summary>
        /// Gets trace definition like: The transport sent a message to '{0}'.
        /// Event description ID=216, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="DestinationAddress">Parameter 0 for event: The transport sent a message to '{0}'.</param>
        internal static void MessageSentByTransport(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string DestinationAddress)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(15))
            {
                TD.WriteEtwEvent(15, eventTraceActivity, DestinationAddress, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=451, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool MessageLogInfoIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(16));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=451, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static bool MessageLogInfo(string param0)
        {
            bool etwTraceResult = true;
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(16))
            {
                etwTraceResult = TD.WriteEtwEvent(16, null, param0, payload.AppDomainFriendlyName);
            }
            return etwTraceResult;
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=452, Level=Warning, Channel=Analytic
        /// </summary>
        internal static bool MessageLogWarningIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(17));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=452, Level=Warning, Channel=Analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static bool MessageLogWarning(string param0)
        {
            bool etwTraceResult = true;
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(17))
            {
                etwTraceResult = TD.WriteEtwEvent(17, null, param0, payload.AppDomainFriendlyName);
            }
            return etwTraceResult;
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=4600, Level=Warning, Channel=debug
        /// </summary>
        internal static bool MessageLogEventSizeExceededIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(18));
        }
        
        /// <summary>
        /// Gets trace definition like: Message could not be logged as it exceeds the ETW event size
        /// Event description ID=4600, Level=Warning, Channel=debug
        /// </summary>
        internal static void MessageLogEventSizeExceeded()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(18))
            {
                TD.WriteEtwEvent(18, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=404, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ResumeSignpostEventIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(19));
        }
        
        /// <summary>
        /// Gets trace definition like: Activity boundary.
        /// Event description ID=404, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="traceRecord">Extended data (TraceRecord) for the event</param>
        internal static void ResumeSignpostEvent(TraceRecord traceRecord)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, traceRecord, null);
            if (TD.IsEtwEventEnabled(19))
            {
                TD.WriteEtwEvent(19, null, payload.ExtendedData, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=402, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool StartSignpostEventIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(20));
        }
        
        /// <summary>
        /// Gets trace definition like: Activity boundary.
        /// Event description ID=402, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="traceRecord">Extended data (TraceRecord) for the event</param>
        internal static void StartSignpostEvent(TraceRecord traceRecord)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, traceRecord, null);
            if (TD.IsEtwEventEnabled(20))
            {
                TD.WriteEtwEvent(20, null, payload.ExtendedData, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=401, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool StopSignpostEventIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(21));
        }
        
        /// <summary>
        /// Gets trace definition like: Activity boundary.
        /// Event description ID=401, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="traceRecord">Extended data (TraceRecord) for the event</param>
        internal static void StopSignpostEvent(TraceRecord traceRecord)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, traceRecord, null);
            if (TD.IsEtwEventEnabled(21))
            {
                TD.WriteEtwEvent(21, null, payload.ExtendedData, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=403, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool SuspendSignpostEventIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(22));
        }
        
        /// <summary>
        /// Gets trace definition like: Activity boundary.
        /// Event description ID=403, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="traceRecord">Extended data (TraceRecord) for the event</param>
        internal static void SuspendSignpostEvent(TraceRecord traceRecord)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, traceRecord, null);
            if (TD.IsEtwEventEnabled(22))
            {
                TD.WriteEtwEvent(22, null, payload.ExtendedData, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=218, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ServiceChannelCallStopIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(23));
        }
        
        /// <summary>
        /// Gets trace definition like: The Client completed executing Action '{0}' associated with the '{1}' contract. The message was sent to '{2}'.
        /// Event description ID=218, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="Action">Parameter 0 for event: The Client completed executing Action '{0}' associated with the '{1}' contract. The message was sent to '{2}'.</param>
        /// <param name="ContractName">Parameter 1 for event: The Client completed executing Action '{0}' associated with the '{1}' contract. The message was sent to '{2}'.</param>
        /// <param name="Destination">Parameter 2 for event: The Client completed executing Action '{0}' associated with the '{1}' contract. The message was sent to '{2}'.</param>
        internal static void ServiceChannelCallStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string Action, string ContractName, string Destination)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(23))
            {
                TD.WriteEtwEvent(23, eventTraceActivity, Action, ContractName, Destination, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=219, Level=Error, Channel=Analytic
        /// </summary>
        internal static bool ServiceExceptionIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(24));
        }
        
        /// <summary>
        /// Gets trace definition like: There was an unhandled exception of type '{1}' during message processing.  Full Exception Details: {0}.
        /// Event description ID=219, Level=Error, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="ExceptionToString">Parameter 0 for event: There was an unhandled exception of type '{1}' during message processing.  Full Exception Details: {0}.</param>
        /// <param name="ExceptionTypeName">Parameter 1 for event: There was an unhandled exception of type '{1}' during message processing.  Full Exception Details: {0}.</param>
        internal static void ServiceException(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string ExceptionToString, string ExceptionTypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(24))
            {
                TD.WriteEtwEvent(24, eventTraceActivity, ExceptionToString, ExceptionTypeName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=222, Level=Warning, Channel=Analytic
        /// </summary>
        internal static bool OperationFailedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(25));
        }
        
        /// <summary>
        /// Gets trace definition like: The '{0}' method threw an unhandled exception when invoked by the OperationInvoker. The method call duration was '{1}' ms.
        /// Event description ID=222, Level=Warning, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="MethodName">Parameter 0 for event: The '{0}' method threw an unhandled exception when invoked by the OperationInvoker. The method call duration was '{1}' ms.</param>
        /// <param name="Duration">Parameter 1 for event: The '{0}' method threw an unhandled exception when invoked by the OperationInvoker. The method call duration was '{1}' ms.</param>
        internal static void OperationFailed(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string MethodName, long Duration)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(25))
            {
                TD.WriteEtwEvent(25, eventTraceActivity, MethodName, Duration, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=223, Level=Warning, Channel=Analytic
        /// </summary>
        internal static bool OperationFaultedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(26));
        }
        
        /// <summary>
        /// Gets trace definition like: The '{0}' method threw a FaultException when invoked by the OperationInvoker. The method call duration was '{1}' ms.
        /// Event description ID=223, Level=Warning, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="MethodName">Parameter 0 for event: The '{0}' method threw a FaultException when invoked by the OperationInvoker. The method call duration was '{1}' ms.</param>
        /// <param name="Duration">Parameter 1 for event: The '{0}' method threw a FaultException when invoked by the OperationInvoker. The method call duration was '{1}' ms.</param>
        internal static void OperationFaulted(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string MethodName, long Duration)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(26))
            {
                TD.WriteEtwEvent(26, eventTraceActivity, MethodName, Duration, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=224, Level=Warning, Channel=Analytic
        /// </summary>
        internal static bool MessageThrottleAtSeventyPercentIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(27));
        }
        
        /// <summary>
        /// Gets trace definition like: The '{0}' throttle limit of '{1}' is at 70%%.
        /// Event description ID=224, Level=Warning, Channel=Analytic
        /// </summary>
        /// <param name="ThrottleName">Parameter 0 for event: The '{0}' throttle limit of '{1}' is at 70%%.</param>
        /// <param name="Limit">Parameter 1 for event: The '{0}' throttle limit of '{1}' is at 70%%.</param>
        internal static void MessageThrottleAtSeventyPercent(string ThrottleName, long Limit)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(27))
            {
                TD.WriteEtwEvent(27, null, ThrottleName, Limit, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=221, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool MessageReceivedFromTransportIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(28));
        }
        
        /// <summary>
        /// Gets trace definition like: The Dispatcher received a message from the transport. Correlation ID == '{0}'.
        /// Event description ID=221, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="CorrelationId">Parameter 0 for event: The Dispatcher received a message from the transport. Correlation ID == '{0}'.</param>
        /// <param name="reference">Reference (e.g. service reference) to be added to trace</param>
        internal static void MessageReceivedFromTransport(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, System.Guid CorrelationId, string reference)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(28))
            {
                TD.WriteEtwEvent(28, eventTraceActivity, CorrelationId, reference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=220, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool MessageSentToTransportIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(29));
        }
        
        /// <summary>
        /// Gets trace definition like: The Dispatcher sent a message to the transport. Correlation ID == '{0}'.
        /// Event description ID=220, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="CorrelationId">Parameter 0 for event: The Dispatcher sent a message to the transport. Correlation ID == '{0}'.</param>
        internal static void MessageSentToTransport(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, System.Guid CorrelationId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(29))
            {
                TD.WriteEtwEvent(29, eventTraceActivity, CorrelationId, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=509, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ServiceHostOpenStartIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(30));
        }
        
        /// <summary>
        /// Gets trace definition like: ServiceHost Open started.
        /// Event description ID=509, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ServiceHostOpenStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(30))
            {
                TD.WriteEtwEvent(30, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=510, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ServiceHostOpenStopIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(31));
        }
        
        /// <summary>
        /// Gets trace definition like: ServiceHost Open completed.
        /// Event description ID=510, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ServiceHostOpenStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(31))
            {
                TD.WriteEtwEvent(31, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=701, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ServiceChannelOpenStartIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(32));
        }
        
        /// <summary>
        /// Gets trace definition like: ServiceChannelOpen started.
        /// Event description ID=701, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ServiceChannelOpenStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(32))
            {
                TD.WriteEtwEvent(32, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=702, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ServiceChannelOpenStopIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(33));
        }
        
        /// <summary>
        /// Gets trace definition like: ServiceChannelOpen completed.
        /// Event description ID=702, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ServiceChannelOpenStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(33))
            {
                TD.WriteEtwEvent(33, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=703, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ServiceChannelCallStartIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(34));
        }
        
        /// <summary>
        /// Gets trace definition like: ServiceChannelCall started.
        /// Event description ID=703, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ServiceChannelCallStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(34))
            {
                TD.WriteEtwEvent(34, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=704, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ServiceChannelBeginCallStartIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(35));
        }
        
        /// <summary>
        /// Gets trace definition like: ServiceChannel asynchronous calls started.
        /// Event description ID=704, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ServiceChannelBeginCallStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(35))
            {
                TD.WriteEtwEvent(35, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=706, Level=verbose, Channel=Debug
        /// </summary>
        internal static bool HttpSendMessageStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(36));
        }
        
        /// <summary>
        /// Gets trace definition like: Http Send Request Start.
        /// Event description ID=706, Level=verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpSendMessageStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(36))
            {
                TD.WriteEtwEvent(36, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=707, Level=verbose, Channel=Debug
        /// </summary>
        internal static bool HttpSendStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(37));
        }
        
        /// <summary>
        /// Gets trace definition like: Http Send Request Stop.
        /// Event description ID=707, Level=verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpSendStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(37))
            {
                TD.WriteEtwEvent(37, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=708, Level=verbose, Channel=analytic
        /// </summary>
        internal static bool HttpMessageReceiveStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(38));
        }
        
        /// <summary>
        /// Gets trace definition like: Message received from http transport.
        /// Event description ID=708, Level=verbose, Channel=analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpMessageReceiveStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(38))
            {
                TD.WriteEtwEvent(38, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=709, Level=Informational, Channel=Analytic
        /// </summary>
        internal static bool DispatchMessageStartIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(39));
        }
        
        /// <summary>
        /// Gets trace definition like: Message dispatching started.
        /// Event description ID=709, Level=Informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void DispatchMessageStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(39))
            {
                TD.WriteEtwEvent(39, eventTraceActivity, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=710, Level=verbose, Channel=Analytic
        /// </summary>
        internal static bool HttpContextBeforeProcessAuthenticationIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(40));
        }
        
        /// <summary>
        /// Gets trace definition like: Start authentication for message dispatching
        /// Event description ID=710, Level=verbose, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpContextBeforeProcessAuthentication(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(40))
            {
                TD.WriteEtwEvent(40, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=711, Level=verbose, Channel=Analytic
        /// </summary>
        internal static bool DispatchMessageBeforeAuthorizationIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(41));
        }
        
        /// <summary>
        /// Gets trace definition like: Start authorization for message dispatching
        /// Event description ID=711, Level=verbose, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void DispatchMessageBeforeAuthorization(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(41))
            {
                TD.WriteEtwEvent(41, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=712, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool DispatchMessageStopIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(42));
        }
        
        /// <summary>
        /// Gets trace definition like: Message dispatching completed
        /// Event description ID=712, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void DispatchMessageStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(42))
            {
                TD.WriteEtwEvent(42, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=715, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ClientChannelOpenStartIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(43));
        }
        
        /// <summary>
        /// Gets trace definition like: ServiceChannel Open Start.
        /// Event description ID=715, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ClientChannelOpenStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(43))
            {
                TD.WriteEtwEvent(43, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=716, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool ClientChannelOpenStopIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(44));
        }
        
        /// <summary>
        /// Gets trace definition like: ServiceChannel Open Stop.
        /// Event description ID=716, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ClientChannelOpenStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(44))
            {
                TD.WriteEtwEvent(44, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=717, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool HttpSendStreamedMessageStartIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(45));
        }
        
        /// <summary>
        /// Gets trace definition like: Http Send streamed message started.
        /// Event description ID=717, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpSendStreamedMessageStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(45))
            {
                TD.WriteEtwEvent(45, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3301, Level=Warning, Channel=debug
        /// </summary>
        internal static bool ReceiveContextAbandonFailedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning 
                        && (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(46)));
        }
        
        /// <summary>
        /// Gets trace definition like: Failed to Abandon {0}.
        /// Event description ID=3301, Level=Warning, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="TypeName">Parameter 0 for event: Failed to Abandon {0}.</param>
        internal static void ReceiveContextAbandonFailed(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string TypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(46))
            {
                TD.WriteEtwEvent(46, eventTraceActivity, TypeName, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceWarningToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ReceiveContextAbandonFailed", Culture), TypeName);
                TD.WriteTraceSource(46, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3303, Level=informational, Channel=debug
        /// </summary>
        internal static bool ReceiveContextAbandonWithExceptionIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(47)));
        }
        
        /// <summary>
        /// Gets trace definition like: {0} was Abandoned with exception {1}.
        /// Event description ID=3303, Level=informational, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="TypeName">Parameter 0 for event: {0} was Abandoned with exception {1}.</param>
        /// <param name="ExceptionToString">Parameter 1 for event: {0} was Abandoned with exception {1}.</param>
        internal static void ReceiveContextAbandonWithException(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string TypeName, string ExceptionToString)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(47))
            {
                TD.WriteEtwEvent(47, eventTraceActivity, TypeName, ExceptionToString, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ReceiveContextAbandonWithException", Culture), TypeName, ExceptionToString);
                TD.WriteTraceSource(47, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3300, Level=Warning, Channel=analytic
        /// </summary>
        internal static bool ReceiveContextCompleteFailedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning 
                        && (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(48)));
        }
        
        /// <summary>
        /// Gets trace definition like: Failed to Complete {0}.
        /// Event description ID=3300, Level=Warning, Channel=analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="TypeName">Parameter 0 for event: Failed to Complete {0}.</param>
        internal static void ReceiveContextCompleteFailed(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string TypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(48))
            {
                TD.WriteEtwEvent(48, eventTraceActivity, TypeName, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceWarningToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ReceiveContextCompleteFailed", Culture), TypeName);
                TD.WriteTraceSource(48, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3302, Level=Warning, Channel=analytic
        /// </summary>
        internal static bool ReceiveContextFaultedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning 
                        && (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(49)));
        }
        
        /// <summary>
        /// Gets trace definition like: Receive Context faulted.
        /// Event description ID=3302, Level=Warning, Channel=analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="source">Source of the event</param>
        internal static void ReceiveContextFaulted(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            if (TD.IsEtwEventEnabled(49))
            {
                TD.WriteEtwEvent(49, eventTraceActivity, payload.EventSource, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceWarningToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ReceiveContextFaulted", Culture));
                TD.WriteTraceSource(49, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3305, Level=informational, Channel=debug
        /// </summary>
        internal static bool ClientBaseCachedChannelFactoryCountIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(50));
        }
        
        /// <summary>
        /// Gets trace definition like: Number of cached channel factories is: '{0}'.  At most '{1}' channel factories can be cached.
        /// Event description ID=3305, Level=informational, Channel=debug
        /// </summary>
        /// <param name="Count">Parameter 0 for event: Number of cached channel factories is: '{0}'.  At most '{1}' channel factories can be cached.</param>
        /// <param name="MaxNum">Parameter 1 for event: Number of cached channel factories is: '{0}'.  At most '{1}' channel factories can be cached.</param>
        /// <param name="source">Source of the event</param>
        internal static void ClientBaseCachedChannelFactoryCount(int Count, int MaxNum, object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            if (TD.IsEtwEventEnabled(50))
            {
                TD.WriteEtwEvent(50, null, Count, MaxNum, payload.EventSource, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3306, Level=informational, Channel=debug
        /// </summary>
        internal static bool ClientBaseChannelFactoryAgedOutofCacheIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(51));
        }
        
        /// <summary>
        /// Gets trace definition like: A channel factory has been aged out of the cache because the cache has reached its limit of '{0}'.
        /// Event description ID=3306, Level=informational, Channel=debug
        /// </summary>
        /// <param name="Count">Parameter 0 for event: A channel factory has been aged out of the cache because the cache has reached its limit of '{0}'.</param>
        /// <param name="source">Source of the event</param>
        internal static void ClientBaseChannelFactoryAgedOutofCache(int Count, object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            if (TD.IsEtwEventEnabled(51))
            {
                TD.WriteEtwEvent(51, null, Count, payload.EventSource, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3307, Level=informational, Channel=debug
        /// </summary>
        internal static bool ClientBaseChannelFactoryCacheHitIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(52));
        }
        
        /// <summary>
        /// Gets trace definition like: Used matching channel factory found in cache.
        /// Event description ID=3307, Level=informational, Channel=debug
        /// </summary>
        /// <param name="source">Source of the event</param>
        internal static void ClientBaseChannelFactoryCacheHit(object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            if (TD.IsEtwEventEnabled(52))
            {
                TD.WriteEtwEvent(52, null, payload.EventSource, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3308, Level=informational, Channel=debug
        /// </summary>
        internal static bool ClientBaseUsingLocalChannelFactoryIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(53));
        }
        
        /// <summary>
        /// Gets trace definition like: Not using channel factory from cache, i.e. caching disabled for instance.
        /// Event description ID=3308, Level=informational, Channel=debug
        /// </summary>
        /// <param name="source">Source of the event</param>
        internal static void ClientBaseUsingLocalChannelFactory(object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            if (TD.IsEtwEventEnabled(53))
            {
                TD.WriteEtwEvent(53, null, payload.EventSource, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3309, Level=informational, Channel=debug
        /// </summary>
        internal static bool QueryCompositionExecutedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(54));
        }
        
        /// <summary>
        /// Gets trace definition like: Query composition using '{0}' was executed on the Request Uri: '{1}'.
        /// Event description ID=3309, Level=informational, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="TypeName">Parameter 0 for event: Query composition using '{0}' was executed on the Request Uri: '{1}'.</param>
        /// <param name="Uri">Parameter 1 for event: Query composition using '{0}' was executed on the Request Uri: '{1}'.</param>
        /// <param name="source">Source of the event</param>
        internal static void QueryCompositionExecuted(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string TypeName, string Uri, object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            if (TD.IsEtwEventEnabled(54))
            {
                TD.WriteEtwEvent(54, eventTraceActivity, TypeName, Uri, payload.EventSource, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3310, Level=Error, Channel=Analytic
        /// </summary>
        internal static bool DispatchFailedIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(55));
        }
        
        /// <summary>
        /// Gets trace definition like: The '{0}' operation was dispatched with errors.
        /// Event description ID=3310, Level=Error, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="OperationName">Parameter 0 for event: The '{0}' operation was dispatched with errors.</param>
        internal static void DispatchFailed(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string OperationName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(55))
            {
                TD.WriteEtwEvent(55, eventTraceActivity, OperationName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3311, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool DispatchSuccessfulIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(56));
        }
        
        /// <summary>
        /// Gets trace definition like: The '{0}' operation was dispatched successfully.
        /// Event description ID=3311, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="OperationName">Parameter 0 for event: The '{0}' operation was dispatched successfully.</param>
        internal static void DispatchSuccessful(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string OperationName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null, true);
            if (TD.IsEtwEventEnabled(56))
            {
                TD.WriteEtwEvent(56, eventTraceActivity, OperationName, payload.HostReference, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3312, Level=informational, Channel=Debug
        /// </summary>
        internal static bool MessageReadByEncoderIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(57));
        }
        
        /// <summary>
        /// Gets trace definition like: A message with size '{0}' bytes was read by the encoder.
        /// Event description ID=3312, Level=informational, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="Size">Parameter 0 for event: A message with size '{0}' bytes was read by the encoder.</param>
        /// <param name="source">Source of the event</param>
        internal static void MessageReadByEncoder(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, int Size, object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            if (TD.IsEtwEventEnabled(57))
            {
                TD.WriteEtwEvent(57, eventTraceActivity, Size, payload.EventSource, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3313, Level=informational, Channel=Debug
        /// </summary>
        internal static bool MessageWrittenByEncoderIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(58));
        }
        
        /// <summary>
        /// Gets trace definition like: A message with size '{0}' bytes was written by the encoder.
        /// Event description ID=3313, Level=informational, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="Size">Parameter 0 for event: A message with size '{0}' bytes was written by the encoder.</param>
        /// <param name="source">Source of the event</param>
        internal static void MessageWrittenByEncoder(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, int Size, object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            if (TD.IsEtwEventEnabled(58))
            {
                TD.WriteEtwEvent(58, eventTraceActivity, Size, payload.EventSource, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3314, Level=Error, Channel=Analytic
        /// </summary>
        internal static bool SessionIdleTimeoutIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(59));
        }
        
        /// <summary>
        /// Gets trace definition like: Session aborting for idle channel to uri:'{0}'.
        /// Event description ID=3314, Level=Error, Channel=Analytic
        /// </summary>
        /// <param name="RemoteAddress">Parameter 0 for event: Session aborting for idle channel to uri:'{0}'.</param>
        internal static void SessionIdleTimeout(string RemoteAddress)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(59))
            {
                TD.WriteEtwEvent(59, null, RemoteAddress, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3319, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SocketAcceptEnqueuedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(60));
        }
        
        /// <summary>
        /// Gets trace definition like: Connection accept started.
        /// Event description ID=3319, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SocketAcceptEnqueued(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(60))
            {
                TD.WriteEtwEvent(60, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3320, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SocketAcceptedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(61));
        }
        
        /// <summary>
        /// Gets trace definition like: ListenerId:{0} accepted SocketId:{1}.
        /// Event description ID=3320, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="ListenerHashCode">Parameter 0 for event: ListenerId:{0} accepted SocketId:{1}.</param>
        /// <param name="SocketHashCode">Parameter 1 for event: ListenerId:{0} accepted SocketId:{1}.</param>
        internal static void SocketAccepted(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, int ListenerHashCode, int SocketHashCode)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(61))
            {
                TD.WriteEtwEvent(61, eventTraceActivity, ListenerHashCode, SocketHashCode, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3321, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ConnectionPoolMissIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(62));
        }
        
        /// <summary>
        /// Gets trace definition like: Pool for {0} has no available connection and {1} busy connections.
        /// Event description ID=3321, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="PoolKey">Parameter 0 for event: Pool for {0} has no available connection and {1} busy connections.</param>
        /// <param name="busy">Parameter 1 for event: Pool for {0} has no available connection and {1} busy connections.</param>
        internal static void ConnectionPoolMiss(string PoolKey, int busy)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(62))
            {
                TD.WriteEtwEvent(62, null, PoolKey, busy, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3322, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool DispatchFormatterDeserializeRequestStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(63));
        }
        
        /// <summary>
        /// Gets trace definition like: Dispatcher started deserialization the request message.
        /// Event description ID=3322, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void DispatchFormatterDeserializeRequestStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(63))
            {
                TD.WriteEtwEvent(63, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3323, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool DispatchFormatterDeserializeRequestStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(64));
        }
        
        /// <summary>
        /// Gets trace definition like: Dispatcher completed deserialization the request message.
        /// Event description ID=3323, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void DispatchFormatterDeserializeRequestStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(64))
            {
                TD.WriteEtwEvent(64, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3324, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool DispatchFormatterSerializeReplyStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(65));
        }
        
        /// <summary>
        /// Gets trace definition like: Dispatcher started serialization of the reply message.
        /// Event description ID=3324, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void DispatchFormatterSerializeReplyStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(65))
            {
                TD.WriteEtwEvent(65, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3325, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool DispatchFormatterSerializeReplyStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(66));
        }
        
        /// <summary>
        /// Gets trace definition like: Dispatcher completed serialization of the reply message.
        /// Event description ID=3325, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void DispatchFormatterSerializeReplyStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(66))
            {
                TD.WriteEtwEvent(66, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3326, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ClientFormatterSerializeRequestStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(67));
        }
        
        /// <summary>
        /// Gets trace definition like: Client request serialization started.
        /// Event description ID=3326, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ClientFormatterSerializeRequestStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(67))
            {
                TD.WriteEtwEvent(67, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3327, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ClientFormatterSerializeRequestStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(68));
        }
        
        /// <summary>
        /// Gets trace definition like: Client completed serialization of the request message.
        /// Event description ID=3327, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ClientFormatterSerializeRequestStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(68))
            {
                TD.WriteEtwEvent(68, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3328, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ClientFormatterDeserializeReplyStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(69));
        }
        
        /// <summary>
        /// Gets trace definition like: Client started deserializing the reply message.
        /// Event description ID=3328, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ClientFormatterDeserializeReplyStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(69))
            {
                TD.WriteEtwEvent(69, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3329, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ClientFormatterDeserializeReplyStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(70));
        }
        
        /// <summary>
        /// Gets trace definition like: Client completed deserializing the reply message.
        /// Event description ID=3329, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ClientFormatterDeserializeReplyStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(70))
            {
                TD.WriteEtwEvent(70, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3330, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SecurityNegotiationStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(71));
        }
        
        /// <summary>
        /// Gets trace definition like: Security negotiation started.
        /// Event description ID=3330, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SecurityNegotiationStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(71))
            {
                TD.WriteEtwEvent(71, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3331, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SecurityNegotiationStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(72));
        }
        
        /// <summary>
        /// Gets trace definition like: Security negotiation completed.
        /// Event description ID=3331, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SecurityNegotiationStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(72))
            {
                TD.WriteEtwEvent(72, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3332, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SecurityTokenProviderOpenedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(73));
        }
        
        /// <summary>
        /// Gets trace definition like: SecurityTokenProvider opening completed.
        /// Event description ID=3332, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SecurityTokenProviderOpened(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(73))
            {
                TD.WriteEtwEvent(73, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3333, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool OutgoingMessageSecuredIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(74));
        }
        
        /// <summary>
        /// Gets trace definition like: Outgoing message has been secured.
        /// Event description ID=3333, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void OutgoingMessageSecured(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(74))
            {
                TD.WriteEtwEvent(74, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3334, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool IncomingMessageVerifiedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(75));
        }
        
        /// <summary>
        /// Gets trace definition like: Incoming message has been verified.
        /// Event description ID=3334, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void IncomingMessageVerified(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(75))
            {
                TD.WriteEtwEvent(75, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3335, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool GetServiceInstanceStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(76));
        }
        
        /// <summary>
        /// Gets trace definition like: Service instance retrieval started.
        /// Event description ID=3335, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void GetServiceInstanceStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(76))
            {
                TD.WriteEtwEvent(76, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3336, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool GetServiceInstanceStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(77));
        }
        
        /// <summary>
        /// Gets trace definition like: Service instance retrieved.
        /// Event description ID=3336, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void GetServiceInstanceStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(77))
            {
                TD.WriteEtwEvent(77, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3337, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ChannelReceiveStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(78));
        }
        
        /// <summary>
        /// Gets trace definition like: ChannelHandlerId:{0} - Message receive loop started.
        /// Event description ID=3337, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="ChannelId">Parameter 0 for event: ChannelHandlerId:{0} - Message receive loop started.</param>
        internal static void ChannelReceiveStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, int ChannelId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(78))
            {
                TD.WriteEtwEvent(78, eventTraceActivity, ChannelId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3338, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ChannelReceiveStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(79));
        }
        
        /// <summary>
        /// Gets trace definition like: ChannelHandlerId:{0} - Message receive loop stopped.
        /// Event description ID=3338, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="ChannelId">Parameter 0 for event: ChannelHandlerId:{0} - Message receive loop stopped.</param>
        internal static void ChannelReceiveStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, int ChannelId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(79))
            {
                TD.WriteEtwEvent(79, eventTraceActivity, ChannelId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3339, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ChannelFactoryCreatedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(80));
        }
        
        /// <summary>
        /// Gets trace definition like: ChannelFactory created .
        /// Event description ID=3339, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="source">Source of the event</param>
        internal static void ChannelFactoryCreated(object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            if (TD.IsEtwEventEnabled(80))
            {
                TD.WriteEtwEvent(80, null, payload.EventSource, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3340, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool PipeConnectionAcceptStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(81));
        }
        
        /// <summary>
        /// Gets trace definition like: Pipe connection accept started on {0} .
        /// Event description ID=3340, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="uri">Parameter 0 for event: Pipe connection accept started on {0} .</param>
        internal static void PipeConnectionAcceptStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string uri)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(81))
            {
                TD.WriteEtwEvent(81, eventTraceActivity, uri, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3341, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool PipeConnectionAcceptStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(82));
        }
        
        /// <summary>
        /// Gets trace definition like: Pipe connection accepted.
        /// Event description ID=3341, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void PipeConnectionAcceptStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(82))
            {
                TD.WriteEtwEvent(82, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3342, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool EstablishConnectionStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(83));
        }
        
        /// <summary>
        /// Gets trace definition like: Connection establishment started for {0}.
        /// Event description ID=3342, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="Key">Parameter 0 for event: Connection establishment started for {0}.</param>
        internal static void EstablishConnectionStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string Key)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(83))
            {
                TD.WriteEtwEvent(83, eventTraceActivity, Key, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3343, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool EstablishConnectionStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(84));
        }
        
        /// <summary>
        /// Gets trace definition like: Connection established.
        /// Event description ID=3343, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void EstablishConnectionStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(84))
            {
                TD.WriteEtwEvent(84, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3345, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SessionPreambleUnderstoodIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(85));
        }
        
        /// <summary>
        /// Gets trace definition like: Session preamble for '{0}' understood.
        /// Event description ID=3345, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="Via">Parameter 0 for event: Session preamble for '{0}' understood.</param>
        internal static void SessionPreambleUnderstood(string Via)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(85))
            {
                TD.WriteEtwEvent(85, null, Via, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3346, Level=Error, Channel=Debug
        /// </summary>
        internal static bool ConnectionReaderSendFaultIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(86));
        }
        
        /// <summary>
        /// Gets trace definition like: Connection reader sending fault '{0}'. 
        /// Event description ID=3346, Level=Error, Channel=Debug
        /// </summary>
        /// <param name="FaultString">Parameter 0 for event: Connection reader sending fault '{0}'. </param>
        internal static void ConnectionReaderSendFault(string FaultString)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(86))
            {
                TD.WriteEtwEvent(86, null, FaultString, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3347, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SocketAcceptClosedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(87));
        }
        
        /// <summary>
        /// Gets trace definition like: Socket accept closed.
        /// Event description ID=3347, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SocketAcceptClosed(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(87))
            {
                TD.WriteEtwEvent(87, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3348, Level=Critical, Channel=analytic
        /// </summary>
        internal static bool ServiceHostFaultedIsEnabled()
        {
            return (FxTrace.ShouldTraceCritical && TD.IsEtwEventEnabled(88));
        }
        
        /// <summary>
        /// Gets trace definition like: Service host faulted.
        /// Event description ID=3348, Level=Critical, Channel=analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="source">Source of the event</param>
        internal static void ServiceHostFaulted(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, object source)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(source, null, null);
            if (TD.IsEtwEventEnabled(88))
            {
                TD.WriteEtwEvent(88, eventTraceActivity, payload.EventSource, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3349, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ListenerOpenStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(89));
        }
        
        /// <summary>
        /// Gets trace definition like: Listener opening for '{0}'.
        /// Event description ID=3349, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="Uri">Parameter 0 for event: Listener opening for '{0}'.</param>
        /// <param name="relatedActivityId">The related event activity Id</param>
        internal static void ListenerOpenStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string Uri, System.Guid relatedActivityId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(89))
            {
                TD.WriteEtwTransferEvent(89, eventTraceActivity, relatedActivityId, Uri, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3350, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ListenerOpenStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(90));
        }
        
        /// <summary>
        /// Gets trace definition like: Listener open completed.
        /// Event description ID=3350, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ListenerOpenStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(90))
            {
                TD.WriteEtwEvent(90, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3351, Level=Verbose, Channel=analytic
        /// </summary>
        internal static bool ServerMaxPooledConnectionsQuotaReachedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(91));
        }
        
        /// <summary>
        /// Gets trace definition like: Server max pooled connections quota reached.
        /// Event description ID=3351, Level=Verbose, Channel=analytic
        /// </summary>
        internal static void ServerMaxPooledConnectionsQuotaReached()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(91))
            {
                TD.WriteEtwEvent(91, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3352, Level=Error, Channel=analytic
        /// </summary>
        internal static bool TcpConnectionTimedOutIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(92));
        }
        
        /// <summary>
        /// Gets trace definition like: SocketId:{0} to remote address {1} timed out.
        /// Event description ID=3352, Level=Error, Channel=analytic
        /// </summary>
        /// <param name="SocketId">Parameter 0 for event: SocketId:{0} to remote address {1} timed out.</param>
        /// <param name="Uri">Parameter 1 for event: SocketId:{0} to remote address {1} timed out.</param>
        internal static void TcpConnectionTimedOut(int SocketId, string Uri)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(92))
            {
                TD.WriteEtwEvent(92, null, SocketId, Uri, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3353, Level=Warning, Channel=analytic
        /// </summary>
        internal static bool TcpConnectionResetErrorIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(93));
        }
        
        /// <summary>
        /// Gets trace definition like: SocketId:{0} to remote address {1} had a connection reset error.
        /// Event description ID=3353, Level=Warning, Channel=analytic
        /// </summary>
        /// <param name="SocketId">Parameter 0 for event: SocketId:{0} to remote address {1} had a connection reset error.</param>
        /// <param name="Uri">Parameter 1 for event: SocketId:{0} to remote address {1} had a connection reset error.</param>
        internal static void TcpConnectionResetError(int SocketId, string Uri)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(93))
            {
                TD.WriteEtwEvent(93, null, SocketId, Uri, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3354, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ServiceSecurityNegotiationCompletedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(94));
        }
        
        /// <summary>
        /// Gets trace definition like: Service security negotiation completed.
        /// Event description ID=3354, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ServiceSecurityNegotiationCompleted(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(94))
            {
                TD.WriteEtwEvent(94, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3355, Level=Error, Channel=analytic
        /// </summary>
        internal static bool SecurityNegotiationProcessingFailureIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(95));
        }
        
        /// <summary>
        /// Gets trace definition like: Security negotiation processing failed.
        /// Event description ID=3355, Level=Error, Channel=analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SecurityNegotiationProcessingFailure(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(95))
            {
                TD.WriteEtwEvent(95, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3356, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SecurityIdentityVerificationSuccessIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(96));
        }
        
        /// <summary>
        /// Gets trace definition like: Security verification succeeded.
        /// Event description ID=3356, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SecurityIdentityVerificationSuccess(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(96))
            {
                TD.WriteEtwEvent(96, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3357, Level=Error, Channel=analytic
        /// </summary>
        internal static bool SecurityIdentityVerificationFailureIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(97));
        }
        
        /// <summary>
        /// Gets trace definition like: Security verification failed.
        /// Event description ID=3357, Level=Error, Channel=analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SecurityIdentityVerificationFailure(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(97))
            {
                TD.WriteEtwEvent(97, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3358, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool PortSharingDuplicatedSocketIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(98));
        }
        
        /// <summary>
        /// Gets trace definition like: Socket duplicated for {0}.
        /// Event description ID=3358, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="Uri">Parameter 0 for event: Socket duplicated for {0}.</param>
        internal static void PortSharingDuplicatedSocket(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string Uri)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(98))
            {
                TD.WriteEtwEvent(98, eventTraceActivity, Uri, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3359, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SecurityImpersonationSuccessIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(99));
        }
        
        /// <summary>
        /// Gets trace definition like: Security impersonation succeeded.
        /// Event description ID=3359, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SecurityImpersonationSuccess(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(99))
            {
                TD.WriteEtwEvent(99, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3360, Level=Warning, Channel=analytic
        /// </summary>
        internal static bool SecurityImpersonationFailureIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(100));
        }
        
        /// <summary>
        /// Gets trace definition like: Security impersonation failed.
        /// Event description ID=3360, Level=Warning, Channel=analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SecurityImpersonationFailure(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(100))
            {
                TD.WriteEtwEvent(100, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3361, Level=Warning, Channel=analytic
        /// </summary>
        internal static bool HttpChannelRequestAbortedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(101));
        }
        
        /// <summary>
        /// Gets trace definition like: Http channel request aborted.
        /// Event description ID=3361, Level=Warning, Channel=analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpChannelRequestAborted(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(101))
            {
                TD.WriteEtwEvent(101, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3362, Level=Warning, Channel=analytic
        /// </summary>
        internal static bool HttpChannelResponseAbortedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(102));
        }
        
        /// <summary>
        /// Gets trace definition like: Http channel response aborted.
        /// Event description ID=3362, Level=Warning, Channel=analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpChannelResponseAborted(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(102))
            {
                TD.WriteEtwEvent(102, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3363, Level=Warning, Channel=analytic
        /// </summary>
        internal static bool HttpAuthFailedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(103));
        }
        
        /// <summary>
        /// Gets trace definition like: Http authentication failed.
        /// Event description ID=3363, Level=Warning, Channel=analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpAuthFailed(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(103))
            {
                TD.WriteEtwEvent(103, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3364, Level=Verbose, Channel=Analytic
        /// </summary>
        internal static bool SharedListenerProxyRegisterStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(104));
        }
        
        /// <summary>
        /// Gets trace definition like: SharedListenerProxy registration started for uri '{0}'.
        /// Event description ID=3364, Level=Verbose, Channel=Analytic
        /// </summary>
        /// <param name="Uri">Parameter 0 for event: SharedListenerProxy registration started for uri '{0}'.</param>
        internal static void SharedListenerProxyRegisterStart(string Uri)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(104))
            {
                TD.WriteEtwEvent(104, null, Uri, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3365, Level=Verbose, Channel=Analytic
        /// </summary>
        internal static bool SharedListenerProxyRegisterStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(105));
        }
        
        /// <summary>
        /// Gets trace definition like: SharedListenerProxy Register Stop.
        /// Event description ID=3365, Level=Verbose, Channel=Analytic
        /// </summary>
        internal static void SharedListenerProxyRegisterStop()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(105))
            {
                TD.WriteEtwEvent(105, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3366, Level=Error, Channel=Analytic
        /// </summary>
        internal static bool SharedListenerProxyRegisterFailedIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(106));
        }
        
        /// <summary>
        /// Gets trace definition like: SharedListenerProxy register failed with status '{0}'.
        /// Event description ID=3366, Level=Error, Channel=Analytic
        /// </summary>
        /// <param name="Status">Parameter 0 for event: SharedListenerProxy register failed with status '{0}'.</param>
        internal static void SharedListenerProxyRegisterFailed(string Status)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(106))
            {
                TD.WriteEtwEvent(106, null, Status, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3367, Level=Error, Channel=Analytic
        /// </summary>
        internal static bool ConnectionPoolPreambleFailedIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(107));
        }
        
        /// <summary>
        /// Gets trace definition like: ConnectionPoolPreambleFailed.
        /// Event description ID=3367, Level=Error, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ConnectionPoolPreambleFailed(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(107))
            {
                TD.WriteEtwEvent(107, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3368, Level=Verbose, Channel=Analytic
        /// </summary>
        internal static bool SslOnInitiateUpgradeIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(108));
        }
        
        /// <summary>
        /// Gets trace definition like: SslOnAcceptUpgradeStart
        /// Event description ID=3368, Level=Verbose, Channel=Analytic
        /// </summary>
        internal static void SslOnInitiateUpgrade()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(108))
            {
                TD.WriteEtwEvent(108, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3369, Level=Verbose, Channel=Analytic
        /// </summary>
        internal static bool SslOnAcceptUpgradeIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(109));
        }
        
        /// <summary>
        /// Gets trace definition like: SslOnAcceptUpgradeStop
        /// Event description ID=3369, Level=Verbose, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SslOnAcceptUpgrade(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(109))
            {
                TD.WriteEtwEvent(109, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3370, Level=verbose, Channel=Debug
        /// </summary>
        internal static bool BinaryMessageEncodingStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(110));
        }
        
        /// <summary>
        /// Gets trace definition like: BinaryMessageEncoder started encoding the message.
        /// Event description ID=3370, Level=verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void BinaryMessageEncodingStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(110))
            {
                TD.WriteEtwEvent(110, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3371, Level=verbose, Channel=Debug
        /// </summary>
        internal static bool MtomMessageEncodingStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(111));
        }
        
        /// <summary>
        /// Gets trace definition like: MtomMessageEncoder started encoding the message.
        /// Event description ID=3371, Level=verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void MtomMessageEncodingStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(111))
            {
                TD.WriteEtwEvent(111, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3372, Level=verbose, Channel=Debug
        /// </summary>
        internal static bool TextMessageEncodingStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(112));
        }
        
        /// <summary>
        /// Gets trace definition like: TextMessageEncoder started encoding the message.
        /// Event description ID=3372, Level=verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void TextMessageEncodingStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(112))
            {
                TD.WriteEtwEvent(112, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3373, Level=verbose, Channel=Debug
        /// </summary>
        internal static bool BinaryMessageDecodingStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(113));
        }
        
        /// <summary>
        /// Gets trace definition like: BinaryMessageEncoder started decoding the message.
        /// Event description ID=3373, Level=verbose, Channel=Debug
        /// </summary>
        internal static void BinaryMessageDecodingStart()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(113))
            {
                TD.WriteEtwEvent(113, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3374, Level=verbose, Channel=Debug
        /// </summary>
        internal static bool MtomMessageDecodingStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(114));
        }
        
        /// <summary>
        /// Gets trace definition like: MtomMessageEncoder started decoding  the message.
        /// Event description ID=3374, Level=verbose, Channel=Debug
        /// </summary>
        internal static void MtomMessageDecodingStart()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(114))
            {
                TD.WriteEtwEvent(114, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3375, Level=verbose, Channel=Debug
        /// </summary>
        internal static bool TextMessageDecodingStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(115));
        }
        
        /// <summary>
        /// Gets trace definition like: TextMessageEncoder started decoding the message.
        /// Event description ID=3375, Level=verbose, Channel=Debug
        /// </summary>
        internal static void TextMessageDecodingStart()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(115))
            {
                TD.WriteEtwEvent(115, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3376, Level=informational, Channel=Debug
        /// </summary>
        internal static bool HttpResponseReceiveStartIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(116));
        }
        
        /// <summary>
        /// Gets trace definition like: Http transport started receiving a message.
        /// Event description ID=3376, Level=informational, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpResponseReceiveStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(116))
            {
                TD.WriteEtwEvent(116, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3377, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SocketReadStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(117));
        }
        
        /// <summary>
        /// Gets trace definition like: SocketId:{0} read '{1}' bytes read from '{2}'.
        /// Event description ID=3377, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="SocketId">Parameter 0 for event: SocketId:{0} read '{1}' bytes read from '{2}'.</param>
        /// <param name="Size">Parameter 1 for event: SocketId:{0} read '{1}' bytes read from '{2}'.</param>
        /// <param name="Endpoint">Parameter 2 for event: SocketId:{0} read '{1}' bytes read from '{2}'.</param>
        internal static void SocketReadStop(int SocketId, int Size, string Endpoint)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(117))
            {
                TD.WriteEtwEvent(117, null, SocketId, Size, Endpoint, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3378, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SocketAsyncReadStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(118));
        }
        
        /// <summary>
        /// Gets trace definition like: SocketId:{0} read '{1}' bytes read from '{2}'.
        /// Event description ID=3378, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="SocketId">Parameter 0 for event: SocketId:{0} read '{1}' bytes read from '{2}'.</param>
        /// <param name="Size">Parameter 1 for event: SocketId:{0} read '{1}' bytes read from '{2}'.</param>
        /// <param name="Endpoint">Parameter 2 for event: SocketId:{0} read '{1}' bytes read from '{2}'.</param>
        internal static void SocketAsyncReadStop(int SocketId, int Size, string Endpoint)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(118))
            {
                TD.WriteEtwEvent(118, null, SocketId, Size, Endpoint, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3379, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SocketWriteStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(119));
        }
        
        /// <summary>
        /// Gets trace definition like: SocketId:{0} writing '{1}' bytes to '{2}'.
        /// Event description ID=3379, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="SocketId">Parameter 0 for event: SocketId:{0} writing '{1}' bytes to '{2}'.</param>
        /// <param name="Size">Parameter 1 for event: SocketId:{0} writing '{1}' bytes to '{2}'.</param>
        /// <param name="Endpoint">Parameter 2 for event: SocketId:{0} writing '{1}' bytes to '{2}'.</param>
        internal static void SocketWriteStart(int SocketId, int Size, string Endpoint)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(119))
            {
                TD.WriteEtwEvent(119, null, SocketId, Size, Endpoint, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3380, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SocketAsyncWriteStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(120));
        }
        
        /// <summary>
        /// Gets trace definition like: SocketId:{0} writing '{1}' bytes to '{2}'.
        /// Event description ID=3380, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="SocketId">Parameter 0 for event: SocketId:{0} writing '{1}' bytes to '{2}'.</param>
        /// <param name="Size">Parameter 1 for event: SocketId:{0} writing '{1}' bytes to '{2}'.</param>
        /// <param name="Endpoint">Parameter 2 for event: SocketId:{0} writing '{1}' bytes to '{2}'.</param>
        internal static void SocketAsyncWriteStart(int SocketId, int Size, string Endpoint)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(120))
            {
                TD.WriteEtwEvent(120, null, SocketId, Size, Endpoint, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3381, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SequenceAcknowledgementSentIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(121));
        }
        
        /// <summary>
        /// Gets trace definition like: SessionId:{0} acknowledgement sent.
        /// Event description ID=3381, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="SessionId">Parameter 0 for event: SessionId:{0} acknowledgement sent.</param>
        internal static void SequenceAcknowledgementSent(string SessionId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(121))
            {
                TD.WriteEtwEvent(121, null, SessionId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3382, Level=Informational, Channel=Debug
        /// </summary>
        internal static bool ClientReliableSessionReconnectIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(122));
        }
        
        /// <summary>
        /// Gets trace definition like: SessionId:{0} reconnecting.
        /// Event description ID=3382, Level=Informational, Channel=Debug
        /// </summary>
        /// <param name="SessionId">Parameter 0 for event: SessionId:{0} reconnecting.</param>
        internal static void ClientReliableSessionReconnect(string SessionId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(122))
            {
                TD.WriteEtwEvent(122, null, SessionId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3383, Level=Informational, Channel=Debug
        /// </summary>
        internal static bool ReliableSessionChannelFaultedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(123));
        }
        
        /// <summary>
        /// Gets trace definition like: SessionId:{0} faulted.
        /// Event description ID=3383, Level=Informational, Channel=Debug
        /// </summary>
        /// <param name="SessionId">Parameter 0 for event: SessionId:{0} faulted.</param>
        internal static void ReliableSessionChannelFaulted(string SessionId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(123))
            {
                TD.WriteEtwEvent(123, null, SessionId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3384, Level=Verbose, Channel=Analytic
        /// </summary>
        internal static bool WindowsStreamSecurityOnInitiateUpgradeIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(124));
        }
        
        /// <summary>
        /// Gets trace definition like: WindowsStreamSecurity initiating security upgrade.
        /// Event description ID=3384, Level=Verbose, Channel=Analytic
        /// </summary>
        internal static void WindowsStreamSecurityOnInitiateUpgrade()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(124))
            {
                TD.WriteEtwEvent(124, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3385, Level=Verbose, Channel=Analytic
        /// </summary>
        internal static bool WindowsStreamSecurityOnAcceptUpgradeIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(125));
        }
        
        /// <summary>
        /// Gets trace definition like: Windows streaming security on accepting upgrade.
        /// Event description ID=3385, Level=Verbose, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void WindowsStreamSecurityOnAcceptUpgrade(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(125))
            {
                TD.WriteEtwEvent(125, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3386, Level=Warning, Channel=analytic
        /// </summary>
        internal static bool SocketConnectionAbortIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(126));
        }
        
        /// <summary>
        /// Gets trace definition like: SocketId:{0} is aborting.
        /// Event description ID=3386, Level=Warning, Channel=analytic
        /// </summary>
        /// <param name="SocketId">Parameter 0 for event: SocketId:{0} is aborting.</param>
        internal static void SocketConnectionAbort(int SocketId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(126))
            {
                TD.WriteEtwEvent(126, null, SocketId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3388, Level=Verbose, Channel=Analytic
        /// </summary>
        internal static bool HttpGetContextStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(127));
        }
        
        /// <summary>
        /// Gets trace definition like: HttpGetContext start.
        /// Event description ID=3388, Level=Verbose, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpGetContextStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(127))
            {
                TD.WriteEtwEvent(127, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3389, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ClientSendPreambleStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(128));
        }
        
        /// <summary>
        /// Gets trace definition like: Client sending preamble start.
        /// Event description ID=3389, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ClientSendPreambleStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(128))
            {
                TD.WriteEtwEvent(128, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3390, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool ClientSendPreambleStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(129));
        }
        
        /// <summary>
        /// Gets trace definition like: Client sending preamble stop.
        /// Event description ID=3390, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void ClientSendPreambleStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(129))
            {
                TD.WriteEtwEvent(129, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3391, Level=Warning, Channel=Analytic
        /// </summary>
        internal static bool HttpMessageReceiveFailedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(130));
        }
        
        /// <summary>
        /// Gets trace definition like: Http Message receive failed.
        /// Event description ID=3391, Level=Warning, Channel=Analytic
        /// </summary>
        internal static void HttpMessageReceiveFailed()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(130))
            {
                TD.WriteEtwEvent(130, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3392, Level=Informational, Channel=Debug
        /// </summary>
        internal static bool TransactionScopeCreateIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(131));
        }
        
        /// <summary>
        /// Gets trace definition like: TransactionScope is being created with LocalIdentifier:'{0}' and DistributedIdentifier:'{1}'.
        /// Event description ID=3392, Level=Informational, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="LocalId">Parameter 0 for event: TransactionScope is being created with LocalIdentifier:'{0}' and DistributedIdentifier:'{1}'.</param>
        /// <param name="Distributed">Parameter 1 for event: TransactionScope is being created with LocalIdentifier:'{0}' and DistributedIdentifier:'{1}'.</param>
        internal static void TransactionScopeCreate(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string LocalId, System.Guid Distributed)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(131))
            {
                TD.WriteEtwEvent(131, eventTraceActivity, LocalId, Distributed, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3393, Level=informational, Channel=Debug
        /// </summary>
        internal static bool StreamedMessageReadByEncoderIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(132));
        }
        
        /// <summary>
        /// Gets trace definition like: A streamed message was read by the encoder.
        /// Event description ID=3393, Level=informational, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void StreamedMessageReadByEncoder(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(132))
            {
                TD.WriteEtwEvent(132, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3394, Level=informational, Channel=Debug
        /// </summary>
        internal static bool StreamedMessageWrittenByEncoderIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(133));
        }
        
        /// <summary>
        /// Gets trace definition like: A streamed message was written by the encoder.
        /// Event description ID=3394, Level=informational, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void StreamedMessageWrittenByEncoder(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(133))
            {
                TD.WriteEtwEvent(133, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3395, Level=informational, Channel=Debug
        /// </summary>
        internal static bool MessageWrittenAsynchronouslyByEncoderIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(134));
        }
        
        /// <summary>
        /// Gets trace definition like: A message was written asynchronously by the encoder.
        /// Event description ID=3395, Level=informational, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void MessageWrittenAsynchronouslyByEncoder(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(134))
            {
                TD.WriteEtwEvent(134, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3396, Level=informational, Channel=Debug
        /// </summary>
        internal static bool BufferedAsyncWriteStartIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(135));
        }
        
        /// <summary>
        /// Gets trace definition like: BufferId:{0} completed writing '{1}' bytes to underlying stream.
        /// Event description ID=3396, Level=informational, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="BufferId">Parameter 0 for event: BufferId:{0} completed writing '{1}' bytes to underlying stream.</param>
        /// <param name="Size">Parameter 1 for event: BufferId:{0} completed writing '{1}' bytes to underlying stream.</param>
        internal static void BufferedAsyncWriteStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, int BufferId, int Size)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(135))
            {
                TD.WriteEtwEvent(135, eventTraceActivity, BufferId, Size, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3397, Level=informational, Channel=Debug
        /// </summary>
        internal static bool BufferedAsyncWriteStopIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(136));
        }
        
        /// <summary>
        /// Gets trace definition like: A message was written asynchronously by the encoder.
        /// Event description ID=3397, Level=informational, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void BufferedAsyncWriteStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(136))
            {
                TD.WriteEtwEvent(136, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1400, Level=error, Channel=analytic
        /// </summary>
        internal static bool ChannelInitializationTimeoutIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(137));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1400, Level=error, Channel=analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static void ChannelInitializationTimeout(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(137))
            {
                TD.WriteEtwEvent(137, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1401, Level=error, Channel=analytic
        /// </summary>
        internal static bool CloseTimeoutIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(138));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1401, Level=error, Channel=analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static void CloseTimeout(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(138))
            {
                TD.WriteEtwEvent(138, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1402, Level=error, Channel=analytic
        /// </summary>
        internal static bool IdleTimeoutIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(139));
        }
        
        /// <summary>
        /// Gets trace definition like: {0} Connection pool key: {1}
        /// Event description ID=1402, Level=error, Channel=analytic
        /// </summary>
        /// <param name="msg">Parameter 0 for event: {0} Connection pool key: {1}</param>
        /// <param name="key">Parameter 1 for event: {0} Connection pool key: {1}</param>
        internal static void IdleTimeout(string msg, string key)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(139))
            {
                TD.WriteEtwEvent(139, null, msg, key, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1403, Level=informational, Channel=analytic
        /// </summary>
        internal static bool LeaseTimeoutIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(140));
        }
        
        /// <summary>
        /// Gets trace definition like: {0} Connection pool key: {1}
        /// Event description ID=1403, Level=informational, Channel=analytic
        /// </summary>
        /// <param name="msg">Parameter 0 for event: {0} Connection pool key: {1}</param>
        /// <param name="key">Parameter 1 for event: {0} Connection pool key: {1}</param>
        internal static void LeaseTimeout(string msg, string key)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(140))
            {
                TD.WriteEtwEvent(140, null, msg, key, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1405, Level=error, Channel=analytic
        /// </summary>
        internal static bool OpenTimeoutIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(141));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1405, Level=error, Channel=analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static void OpenTimeout(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(141))
            {
                TD.WriteEtwEvent(141, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1406, Level=error, Channel=analytic
        /// </summary>
        internal static bool ReceiveTimeoutIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(142));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1406, Level=error, Channel=analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static void ReceiveTimeout(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(142))
            {
                TD.WriteEtwEvent(142, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1407, Level=error, Channel=analytic
        /// </summary>
        internal static bool SendTimeoutIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(143));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1407, Level=error, Channel=analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static void SendTimeout(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(143))
            {
                TD.WriteEtwEvent(143, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1409, Level=informational, Channel=analytic
        /// </summary>
        internal static bool InactivityTimeoutIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(144));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1409, Level=informational, Channel=analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static void InactivityTimeout(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(144))
            {
                TD.WriteEtwEvent(144, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1416, Level=error, Channel=analytic
        /// </summary>
        internal static bool MaxReceivedMessageSizeExceededIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(145));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1416, Level=error, Channel=analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static void MaxReceivedMessageSizeExceeded(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(145))
            {
                TD.WriteEtwEvent(145, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1417, Level=error, Channel=analytic
        /// </summary>
        internal static bool MaxSentMessageSizeExceededIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(146));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1417, Level=error, Channel=analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static void MaxSentMessageSizeExceeded(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(146))
            {
                TD.WriteEtwEvent(146, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1418, Level=informational, Channel=debug
        /// </summary>
        internal static bool MaxOutboundConnectionsPerEndpointExceededIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(147));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1418, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static void MaxOutboundConnectionsPerEndpointExceeded(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(147))
            {
                TD.WriteEtwEvent(147, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1419, Level=informational, Channel=debug
        /// </summary>
        internal static bool MaxPendingConnectionsExceededIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(148));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1419, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static void MaxPendingConnectionsExceeded(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(148))
            {
                TD.WriteEtwEvent(148, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1422, Level=error, Channel=analytic
        /// </summary>
        internal static bool NegotiateTokenAuthenticatorStateCacheExceededIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(149));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1422, Level=error, Channel=analytic
        /// </summary>
        /// <param name="msg">Parameter 0 for event: {0}</param>
        internal static void NegotiateTokenAuthenticatorStateCacheExceeded(string msg)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(149))
            {
                TD.WriteEtwEvent(149, null, msg, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1423, Level=verbose, Channel=debug
        /// </summary>
        internal static bool NegotiateTokenAuthenticatorStateCacheRatioIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(150));
        }
        
        /// <summary>
        /// Gets trace definition like: Negotiate token authenticator state cache ratio: {0}/{1}
        /// Event description ID=1423, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="cur">Parameter 0 for event: Negotiate token authenticator state cache ratio: {0}/{1}</param>
        /// <param name="max">Parameter 1 for event: Negotiate token authenticator state cache ratio: {0}/{1}</param>
        internal static void NegotiateTokenAuthenticatorStateCacheRatio(int cur, int max)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(150))
            {
                TD.WriteEtwEvent(150, null, cur, max, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1424, Level=verbose, Channel=debug
        /// </summary>
        internal static bool SecuritySessionRatioIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(151));
        }
        
        /// <summary>
        /// Gets trace definition like: Security session ratio: {0}/{1}
        /// Event description ID=1424, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="cur">Parameter 0 for event: Security session ratio: {0}/{1}</param>
        /// <param name="max">Parameter 1 for event: Security session ratio: {0}/{1}</param>
        internal static void SecuritySessionRatio(int cur, int max)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(151))
            {
                TD.WriteEtwEvent(151, null, cur, max, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1430, Level=verbose, Channel=analytic
        /// </summary>
        internal static bool PendingConnectionsRatioIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(152));
        }
        
        /// <summary>
        /// Gets trace definition like: Pending connections ratio: {0}/{1}
        /// Event description ID=1430, Level=verbose, Channel=analytic
        /// </summary>
        /// <param name="cur">Parameter 0 for event: Pending connections ratio: {0}/{1}</param>
        /// <param name="max">Parameter 1 for event: Pending connections ratio: {0}/{1}</param>
        internal static void PendingConnectionsRatio(int cur, int max)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(152))
            {
                TD.WriteEtwEvent(152, null, cur, max, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1433, Level=verbose, Channel=analytic
        /// </summary>
        internal static bool OutboundConnectionsPerEndpointRatioIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(153));
        }
        
        /// <summary>
        /// Gets trace definition like: Outbound connections per endpoint ratio: {0}/{1}
        /// Event description ID=1433, Level=verbose, Channel=analytic
        /// </summary>
        /// <param name="cur">Parameter 0 for event: Outbound connections per endpoint ratio: {0}/{1}</param>
        /// <param name="max">Parameter 1 for event: Outbound connections per endpoint ratio: {0}/{1}</param>
        internal static void OutboundConnectionsPerEndpointRatio(int cur, int max)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(153))
            {
                TD.WriteEtwEvent(153, null, cur, max, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1438, Level=verbose, Channel=analytic
        /// </summary>
        internal static bool ConcurrentInstancesRatioIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(154));
        }
        
        /// <summary>
        /// Gets trace definition like: Concurrent instances ratio: {0}/{1}
        /// Event description ID=1438, Level=verbose, Channel=analytic
        /// </summary>
        /// <param name="cur">Parameter 0 for event: Concurrent instances ratio: {0}/{1}</param>
        /// <param name="max">Parameter 1 for event: Concurrent instances ratio: {0}/{1}</param>
        internal static void ConcurrentInstancesRatio(int cur, int max)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(154))
            {
                TD.WriteEtwEvent(154, null, cur, max, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1432, Level=verbose, Channel=analytic
        /// </summary>
        internal static bool ConcurrentSessionsRatioIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(155));
        }
        
        /// <summary>
        /// Gets trace definition like: Concurrent sessions ratio: {0}/{1}
        /// Event description ID=1432, Level=verbose, Channel=analytic
        /// </summary>
        /// <param name="cur">Parameter 0 for event: Concurrent sessions ratio: {0}/{1}</param>
        /// <param name="max">Parameter 1 for event: Concurrent sessions ratio: {0}/{1}</param>
        internal static void ConcurrentSessionsRatio(int cur, int max)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(155))
            {
                TD.WriteEtwEvent(155, null, cur, max, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1431, Level=verbose, Channel=analytic
        /// </summary>
        internal static bool ConcurrentCallsRatioIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(156));
        }
        
        /// <summary>
        /// Gets trace definition like: Concurrent calls ratio: {0}/{1}
        /// Event description ID=1431, Level=verbose, Channel=analytic
        /// </summary>
        /// <param name="cur">Parameter 0 for event: Concurrent calls ratio: {0}/{1}</param>
        /// <param name="max">Parameter 1 for event: Concurrent calls ratio: {0}/{1}</param>
        internal static void ConcurrentCallsRatio(int cur, int max)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(156))
            {
                TD.WriteEtwEvent(156, null, cur, max, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1439, Level=informational, Channel=debug
        /// </summary>
        internal static bool PendingAcceptsAtZeroIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(157));
        }
        
        /// <summary>
        /// Gets trace definition like: Zero pending accepts left
        /// Event description ID=1439, Level=informational, Channel=debug
        /// </summary>
        internal static void PendingAcceptsAtZero()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(157))
            {
                TD.WriteEtwEvent(157, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1441, Level=warning, Channel=analytic
        /// </summary>
        internal static bool MaxSessionSizeReachedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(158));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1441, Level=warning, Channel=analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static void MaxSessionSizeReached(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(158))
            {
                TD.WriteEtwEvent(158, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1442, Level=warning, Channel=analytic
        /// </summary>
        internal static bool ReceiveRetryCountReachedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(159));
        }
        
        /// <summary>
        /// Gets trace definition like: Receive retry count reached on MSMQ message with id '{0}'
        /// Event description ID=1442, Level=warning, Channel=analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Receive retry count reached on MSMQ message with id '{0}'</param>
        internal static void ReceiveRetryCountReached(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(159))
            {
                TD.WriteEtwEvent(159, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1443, Level=error, Channel=analytic
        /// </summary>
        internal static bool MaxRetryCyclesExceededMsmqIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(160));
        }
        
        /// <summary>
        /// Gets trace definition like: Max retry cycles exceeded on MSMQ message with id '{0}'
        /// Event description ID=1443, Level=error, Channel=analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Max retry cycles exceeded on MSMQ message with id '{0}'</param>
        internal static void MaxRetryCyclesExceededMsmq(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(160))
            {
                TD.WriteEtwEvent(160, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1445, Level=verbose, Channel=analytic
        /// </summary>
        internal static bool ReadPoolMissIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(161));
        }
        
        /// <summary>
        /// Gets trace definition like: Created new '{0}'
        /// Event description ID=1445, Level=verbose, Channel=analytic
        /// </summary>
        /// <param name="itemTypeName">Parameter 0 for event: Created new '{0}'</param>
        internal static void ReadPoolMiss(string itemTypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(161))
            {
                TD.WriteEtwEvent(161, null, itemTypeName, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1446, Level=verbose, Channel=analytic
        /// </summary>
        internal static bool WritePoolMissIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(162));
        }
        
        /// <summary>
        /// Gets trace definition like: Created new '{0}'
        /// Event description ID=1446, Level=verbose, Channel=analytic
        /// </summary>
        /// <param name="itemTypeName">Parameter 0 for event: Created new '{0}'</param>
        internal static void WritePoolMiss(string itemTypeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(162))
            {
                TD.WriteEtwEvent(162, null, itemTypeName, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1451, Level=error, Channel=analytic
        /// </summary>
        internal static bool MaxRetryCyclesExceededIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(163));
        }
        
        /// <summary>
        /// Gets trace definition like: {0}
        /// Event description ID=1451, Level=error, Channel=analytic
        /// </summary>
        /// <param name="param0">Parameter 0 for event: {0}</param>
        internal static void MaxRetryCyclesExceeded(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(163))
            {
                TD.WriteEtwEvent(163, null, param0, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3398, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool PipeSharedMemoryCreatedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(164));
        }
        
        /// <summary>
        /// Gets trace definition like: Pipe shared memory created at '{0}' .
        /// Event description ID=3398, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="sharedMemoryName">Parameter 0 for event: Pipe shared memory created at '{0}' .</param>
        internal static void PipeSharedMemoryCreated(string sharedMemoryName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(164))
            {
                TD.WriteEtwEvent(164, null, sharedMemoryName, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3399, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool NamedPipeCreatedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(165));
        }
        
        /// <summary>
        /// Gets trace definition like: NamedPipe '{0}' created.
        /// Event description ID=3399, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="pipeName">Parameter 0 for event: NamedPipe '{0}' created.</param>
        internal static void NamedPipeCreated(string pipeName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(165))
            {
                TD.WriteEtwEvent(165, null, pipeName, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3405, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool EncryptedDataProcessingStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(166));
        }
        
        /// <summary>
        /// Gets trace definition like: Encrypted data processing started.
        /// Event description ID=3405, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void EncryptedDataProcessingStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(166))
            {
                TD.WriteEtwEvent(166, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3406, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool EncryptedDataProcessingSuccessIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(167));
        }
        
        /// <summary>
        /// Gets trace definition like: Encrypted data processing succeeded.
        /// Event description ID=3406, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void EncryptedDataProcessingSuccess(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(167))
            {
                TD.WriteEtwEvent(167, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3401, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SignatureVerificationStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(168));
        }
        
        /// <summary>
        /// Gets trace definition like: Signature verification started.
        /// Event description ID=3401, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SignatureVerificationStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(168))
            {
                TD.WriteEtwEvent(168, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3402, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool SignatureVerificationSuccessIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(169));
        }
        
        /// <summary>
        /// Gets trace definition like: Signature verification succeeded
        /// Event description ID=3402, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void SignatureVerificationSuccess(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(169))
            {
                TD.WriteEtwEvent(169, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3403, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WrappedKeyDecryptionStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(170));
        }
        
        /// <summary>
        /// Gets trace definition like: Wrapped key decryption started.
        /// Event description ID=3403, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void WrappedKeyDecryptionStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(170))
            {
                TD.WriteEtwEvent(170, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3404, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WrappedKeyDecryptionSuccessIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(171));
        }
        
        /// <summary>
        /// Gets trace definition like: Wrapped key decryption succeeded.
        /// Event description ID=3404, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void WrappedKeyDecryptionSuccess(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(171))
            {
                TD.WriteEtwEvent(171, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3407, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool HttpPipelineProcessInboundRequestStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(172));
        }
        
        /// <summary>
        /// Gets trace definition like: Http message handler started processing the inbound request.
        /// Event description ID=3407, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpPipelineProcessInboundRequestStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(172))
            {
                TD.WriteEtwEvent(172, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3408, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool HttpPipelineBeginProcessInboundRequestStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(173));
        }
        
        /// <summary>
        /// Gets trace definition like: Http message handler started processing the inbound request asynchronously.
        /// Event description ID=3408, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpPipelineBeginProcessInboundRequestStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(173))
            {
                TD.WriteEtwEvent(173, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3409, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool HttpPipelineProcessInboundRequestStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(174));
        }
        
        /// <summary>
        /// Gets trace definition like: Http message handler completed processing an inbound request.
        /// Event description ID=3409, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpPipelineProcessInboundRequestStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(174))
            {
                TD.WriteEtwEvent(174, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3410, Level=Warning, Channel=ANALYTIC
        /// </summary>
        internal static bool HttpPipelineFaultedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(175));
        }
        
        /// <summary>
        /// Gets trace definition like: Http message handler is faulted.
        /// Event description ID=3410, Level=Warning, Channel=ANALYTIC
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpPipelineFaulted(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(175))
            {
                TD.WriteEtwEvent(175, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3411, Level=Error, Channel=ANALYTIC
        /// </summary>
        internal static bool HttpPipelineTimeoutExceptionIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(176));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocket connection timed out.
        /// Event description ID=3411, Level=Error, Channel=ANALYTIC
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpPipelineTimeoutException(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(176))
            {
                TD.WriteEtwEvent(176, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3412, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool HttpPipelineProcessResponseStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(177));
        }
        
        /// <summary>
        /// Gets trace definition like: Http message handler started processing the response.
        /// Event description ID=3412, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpPipelineProcessResponseStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(177))
            {
                TD.WriteEtwEvent(177, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3413, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool HttpPipelineBeginProcessResponseStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(178));
        }
        
        /// <summary>
        /// Gets trace definition like: Http message handler started processing the response asynchronously.
        /// Event description ID=3413, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpPipelineBeginProcessResponseStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(178))
            {
                TD.WriteEtwEvent(178, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3414, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool HttpPipelineProcessResponseStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(179));
        }
        
        /// <summary>
        /// Gets trace definition like: Http message handler completed processing the response.
        /// Event description ID=3414, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void HttpPipelineProcessResponseStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(179))
            {
                TD.WriteEtwEvent(179, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3415, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketConnectionRequestSendStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(180));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocket connection request to '{0}' send start.
        /// Event description ID=3415, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="remoteAddress">Parameter 0 for event: WebSocket connection request to '{0}' send start.</param>
        internal static void WebSocketConnectionRequestSendStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string remoteAddress)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(180))
            {
                TD.WriteEtwEvent(180, eventTraceActivity, remoteAddress, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3416, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketConnectionRequestSendStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(181));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocketId:{0} connection request sent.
        /// Event description ID=3416, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="websocketId">Parameter 0 for event: WebSocketId:{0} connection request sent.</param>
        internal static void WebSocketConnectionRequestSendStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, int websocketId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(181))
            {
                TD.WriteEtwEvent(181, eventTraceActivity, websocketId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3417, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketConnectionAcceptStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(182));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocket connection accept start.
        /// Event description ID=3417, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void WebSocketConnectionAcceptStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(182))
            {
                TD.WriteEtwEvent(182, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3418, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketConnectionAcceptedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(183));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocketId:{0} connection accepted.
        /// Event description ID=3418, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="websocketId">Parameter 0 for event: WebSocketId:{0} connection accepted.</param>
        internal static void WebSocketConnectionAccepted(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, int websocketId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(183))
            {
                TD.WriteEtwEvent(183, eventTraceActivity, websocketId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3419, Level=Error, Channel=ANALYTIC
        /// </summary>
        internal static bool WebSocketConnectionDeclinedIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(184));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocket connection declined with status code '{0}'
        /// Event description ID=3419, Level=Error, Channel=ANALYTIC
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="errorMessage">Parameter 0 for event: WebSocket connection declined with status code '{0}'</param>
        internal static void WebSocketConnectionDeclined(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string errorMessage)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(184))
            {
                TD.WriteEtwEvent(184, eventTraceActivity, errorMessage, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3420, Level=Error, Channel=ANALYTIC
        /// </summary>
        internal static bool WebSocketConnectionFailedIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(185));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocket connection request failed: '{0}'
        /// Event description ID=3420, Level=Error, Channel=ANALYTIC
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="errorMessage">Parameter 0 for event: WebSocket connection request failed: '{0}'</param>
        internal static void WebSocketConnectionFailed(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string errorMessage)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(185))
            {
                TD.WriteEtwEvent(185, eventTraceActivity, errorMessage, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3421, Level=Error, Channel=ANALYTIC
        /// </summary>
        internal static bool WebSocketConnectionAbortedIsEnabled()
        {
            return (FxTrace.ShouldTraceError && TD.IsEtwEventEnabled(186));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocketId:{0} connection is aborted.
        /// Event description ID=3421, Level=Error, Channel=ANALYTIC
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="websocketId">Parameter 0 for event: WebSocketId:{0} connection is aborted.</param>
        internal static void WebSocketConnectionAborted(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, int websocketId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(186))
            {
                TD.WriteEtwEvent(186, eventTraceActivity, websocketId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3422, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketAsyncWriteStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(187));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocketId:{0} writing '{1}' bytes to '{2}'.
        /// Event description ID=3422, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="websocketId">Parameter 0 for event: WebSocketId:{0} writing '{1}' bytes to '{2}'.</param>
        /// <param name="byteCount">Parameter 1 for event: WebSocketId:{0} writing '{1}' bytes to '{2}'.</param>
        /// <param name="remoteAddress">Parameter 2 for event: WebSocketId:{0} writing '{1}' bytes to '{2}'.</param>
        internal static void WebSocketAsyncWriteStart(int websocketId, int byteCount, string remoteAddress)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(187))
            {
                TD.WriteEtwEvent(187, null, websocketId, byteCount, remoteAddress, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3423, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketAsyncWriteStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(188));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocketId:{0} asynchronous write stop.
        /// Event description ID=3423, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="websocketId">Parameter 0 for event: WebSocketId:{0} asynchronous write stop.</param>
        internal static void WebSocketAsyncWriteStop(int websocketId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(188))
            {
                TD.WriteEtwEvent(188, null, websocketId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3424, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketAsyncReadStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(189));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocketId:{0} read start.
        /// Event description ID=3424, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="websocketId">Parameter 0 for event: WebSocketId:{0} read start.</param>
        internal static void WebSocketAsyncReadStart(int websocketId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(189))
            {
                TD.WriteEtwEvent(189, null, websocketId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3425, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketAsyncReadStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(190));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocketId:{0} read '{1}' bytes from '{2}'.
        /// Event description ID=3425, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="websocketId">Parameter 0 for event: WebSocketId:{0} read '{1}' bytes from '{2}'.</param>
        /// <param name="byteCount">Parameter 1 for event: WebSocketId:{0} read '{1}' bytes from '{2}'.</param>
        /// <param name="remoteAddress">Parameter 2 for event: WebSocketId:{0} read '{1}' bytes from '{2}'.</param>
        internal static void WebSocketAsyncReadStop(int websocketId, int byteCount, string remoteAddress)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(190))
            {
                TD.WriteEtwEvent(190, null, websocketId, byteCount, remoteAddress, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3426, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketCloseSentIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(191));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocketId:{0} sending close message to '{1}' with close status '{2}'.
        /// Event description ID=3426, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="websocketId">Parameter 0 for event: WebSocketId:{0} sending close message to '{1}' with close status '{2}'.</param>
        /// <param name="remoteAddress">Parameter 1 for event: WebSocketId:{0} sending close message to '{1}' with close status '{2}'.</param>
        /// <param name="closeStatus">Parameter 2 for event: WebSocketId:{0} sending close message to '{1}' with close status '{2}'.</param>
        internal static void WebSocketCloseSent(int websocketId, string remoteAddress, string closeStatus)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(191))
            {
                TD.WriteEtwEvent(191, null, websocketId, remoteAddress, closeStatus, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3427, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketCloseOutputSentIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(192));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocketId:{0} sending close output message to '{1}' with close status '{2}'.
        /// Event description ID=3427, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="websocketId">Parameter 0 for event: WebSocketId:{0} sending close output message to '{1}' with close status '{2}'.</param>
        /// <param name="remoteAddress">Parameter 1 for event: WebSocketId:{0} sending close output message to '{1}' with close status '{2}'.</param>
        /// <param name="closeStatus">Parameter 2 for event: WebSocketId:{0} sending close output message to '{1}' with close status '{2}'.</param>
        internal static void WebSocketCloseOutputSent(int websocketId, string remoteAddress, string closeStatus)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(192))
            {
                TD.WriteEtwEvent(192, null, websocketId, remoteAddress, closeStatus, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3428, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketConnectionClosedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(193));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocketId:{0} connection closed.
        /// Event description ID=3428, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="websocketId">Parameter 0 for event: WebSocketId:{0} connection closed.</param>
        internal static void WebSocketConnectionClosed(int websocketId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(193))
            {
                TD.WriteEtwEvent(193, null, websocketId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3429, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketCloseStatusReceivedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(194));
        }
        
        /// <summary>
        /// Gets trace definition like: WebSocketId:{0} connection close message received with status '{1}'.
        /// Event description ID=3429, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="websocketId">Parameter 0 for event: WebSocketId:{0} connection close message received with status '{1}'.</param>
        /// <param name="closeStatus">Parameter 1 for event: WebSocketId:{0} connection close message received with status '{1}'.</param>
        internal static void WebSocketCloseStatusReceived(int websocketId, string closeStatus)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(194))
            {
                TD.WriteEtwEvent(194, null, websocketId, closeStatus, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3430, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketUseVersionFromClientWebSocketFactoryIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(195));
        }
        
        /// <summary>
        /// Gets trace definition like: Using the WebSocketVersion from a client WebSocket factory of type '{0}'.
        /// Event description ID=3430, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="clientWebSocketFactoryType">Parameter 0 for event: Using the WebSocketVersion from a client WebSocket factory of type '{0}'.</param>
        internal static void WebSocketUseVersionFromClientWebSocketFactory(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string clientWebSocketFactoryType)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(195))
            {
                TD.WriteEtwEvent(195, eventTraceActivity, clientWebSocketFactoryType, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3431, Level=Verbose, Channel=Debug
        /// </summary>
        internal static bool WebSocketCreateClientWebSocketWithFactoryIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(196));
        }
        
        /// <summary>
        /// Gets trace definition like: Creating the client WebSocket with a factory of type '{0}'.
        /// Event description ID=3431, Level=Verbose, Channel=Debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="clientWebSocketFactoryType">Parameter 0 for event: Creating the client WebSocket with a factory of type '{0}'.</param>
        internal static void WebSocketCreateClientWebSocketWithFactory(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string clientWebSocketFactoryType)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(196))
            {
                TD.WriteEtwEvent(196, eventTraceActivity, clientWebSocketFactoryType, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Creates the event descriptors array
        /// </summary>
        // Critical = Sets the SecurityCritical member eventDescriptors
        // Safe = We control what the event descriptors contain
        [System.Security.SecuritySafeCriticalAttribute()]
        static void CreateEventDescriptors()
        {
            System.Runtime.Diagnostics.EventDescriptor[] descriptors = new System.Runtime.Diagnostics.EventDescriptor[] {
                    new System.Runtime.Diagnostics.EventDescriptor(217, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)20, 0x9d2, 0x1000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(201, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)16, 0x9d2, 0x1000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(202, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)17, 0x9d2, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(203, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)19, 0x9d2, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(204, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)18, 0x9d2, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(205, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)53, 0x9e5, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(206, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x0, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(207, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x0, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(208, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)51, 0x9e5, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(209, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)52, 0x9e5, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(210, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0x0, 0x20000000004E0004),
                    new System.Runtime.Diagnostics.EventDescriptor(211, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)56, 0x9e5, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(212, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)55, 0x9e5, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(214, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)54, 0x9e5, 0x20000000000E0004),
                    new System.Runtime.Diagnostics.EventDescriptor(215, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0xa27, 0x2000000000080400),
                    new System.Runtime.Diagnostics.EventDescriptor(216, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0xa28, 0x2000000000080400),
                    new System.Runtime.Diagnostics.EventDescriptor(451, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x0, 0x2000000000080020),
                    new System.Runtime.Diagnostics.EventDescriptor(452, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0x0, 0x2000000000080020),
                    new System.Runtime.Diagnostics.EventDescriptor(4600, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0x0, 0x1000000000000020),
                    new System.Runtime.Diagnostics.EventDescriptor(404, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Resume, 0xa1c, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(402, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Start, 0xa1c, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(401, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0xa1c, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(403, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Suspend, 0xa1c, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(218, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0xa10, 0x2000000000080004),
                    new System.Runtime.Diagnostics.EventDescriptor(219, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0x9e5, 0x20000000000E0004),
                    new System.Runtime.Diagnostics.EventDescriptor(222, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0x9e5, 0x20000000000E0004),
                    new System.Runtime.Diagnostics.EventDescriptor(223, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0x9e5, 0x20000000000E0004),
                    new System.Runtime.Diagnostics.EventDescriptor(224, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0x9e5, 0x20000000004E0004),
                    new System.Runtime.Diagnostics.EventDescriptor(221, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x0, 0x20000000000A0400),
                    new System.Runtime.Diagnostics.EventDescriptor(220, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x0, 0x20000000000A0400),
                    new System.Runtime.Diagnostics.EventDescriptor(509, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Start, 0xa17, 0x2000000000000001),
                    new System.Runtime.Diagnostics.EventDescriptor(510, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0xa17, 0x2000000000000001),
                    new System.Runtime.Diagnostics.EventDescriptor(701, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Start, 0xa11, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(702, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0xa11, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(703, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Start, 0xa10, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(704, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Start, 0xa10, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(706, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa28, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(707, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0xa28, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(708, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa27, 0x2000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(709, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)49, 0x9e5, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(710, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)128, 0xa27, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(711, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)48, 0x9e5, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(712, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)50, 0x9e5, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(715, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)14, 0x9d2, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(716, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)15, 0x9d2, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(717, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Start, 0xa28, 0x2000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3301, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0x0, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3303, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x0, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3300, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0x0, 0x2000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3302, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0x9e5, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3305, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x9cf, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3306, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x9cf, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3307, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x9cf, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3308, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x9cf, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3309, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x0, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3310, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0x9e5, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3311, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0x9e5, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3312, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0x9fb, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3313, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0x9fc, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3314, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa23, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3319, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9d9, 0x1000000000000200),
                    new System.Runtime.Diagnostics.EventDescriptor(3320, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9d9, 0x1000000000000200),
                    new System.Runtime.Diagnostics.EventDescriptor(3321, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9da, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3322, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9ec, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3323, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9ec, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3324, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9ed, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3325, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9ed, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3326, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9ee, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3327, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9ee, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3328, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9eb, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3329, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9eb, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3330, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa0d, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3331, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0xa0d, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3332, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa0b, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3333, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0xa0b, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3334, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa0e, 0x1000000000000014),
                    new System.Runtime.Diagnostics.EventDescriptor(3335, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa18, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3336, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0xa18, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3337, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9d1, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3338, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9d1, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3339, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9d0, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3340, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9d9, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3341, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9d9, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3342, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9d7, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3343, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9d7, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3345, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9d7, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3346, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0x9d7, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3347, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9d9, 0x1000000000000200),
                    new System.Runtime.Diagnostics.EventDescriptor(3348, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Critical, (byte)TraceEventOpcode.Info, 0xa16, 0x2000000000000200),
                    new System.Runtime.Diagnostics.EventDescriptor(3349, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9f8, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3350, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9f8, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3351, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(3352, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0x9d7, 0x2000000000000200),
                    new System.Runtime.Diagnostics.EventDescriptor(3353, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0x9d7, 0x2000000000000200),
                    new System.Runtime.Diagnostics.EventDescriptor(3354, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa0d, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3355, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa0d, 0x2000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3356, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa0e, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3357, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa0e, 0x2000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3358, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9c5, 0x1000000000000800),
                    new System.Runtime.Diagnostics.EventDescriptor(3359, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa0c, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3360, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0xa0c, 0x2000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3361, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0xa27, 0x2000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3362, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0xa28, 0x2000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3363, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0xa0e, 0x2000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3364, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9c6, 0x2000000000000800),
                    new System.Runtime.Diagnostics.EventDescriptor(3365, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9c6, 0x2000000000000800),
                    new System.Runtime.Diagnostics.EventDescriptor(3366, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0x9c6, 0x2000000000000800),
                    new System.Runtime.Diagnostics.EventDescriptor(3367, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa1a, 0x2000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3368, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)115, 0xa1b, 0x2000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3369, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)114, 0xa1b, 0x2000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3370, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9fc, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3371, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9fc, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3372, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9fc, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3373, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9fb, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3374, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9fb, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3375, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9fb, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3376, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Start, 0xa27, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3377, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0xa27, 0x1000000000000200),
                    new System.Runtime.Diagnostics.EventDescriptor(3378, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0xa27, 0x1000000000000200),
                    new System.Runtime.Diagnostics.EventDescriptor(3379, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa28, 0x1000000000000200),
                    new System.Runtime.Diagnostics.EventDescriptor(3380, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa28, 0x1000000000000200),
                    new System.Runtime.Diagnostics.EventDescriptor(3381, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)79, 0xa01, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3382, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)78, 0xa01, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3383, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)77, 0xa01, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3384, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)115, 0xa1b, 0x2000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3385, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)114, 0xa1b, 0x2000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3386, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0x9d8, 0x2000000000000200),
                    new System.Runtime.Diagnostics.EventDescriptor(3388, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa27, 0x2000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3389, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9d3, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3390, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9d3, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3391, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Start, 0xa27, 0x2000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3392, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)57, 0x9e5, 0x1000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(3393, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0x9fb, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3394, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0x9fc, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3395, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0x9fc, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3396, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Start, 0xa28, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3397, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0xa28, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(1400, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa24, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(1401, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa24, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(1402, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa24, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(1403, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0xa24, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(1405, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa24, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(1406, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa24, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(1407, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa24, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(1409, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0xa24, 0x2000000000000004),
                    new System.Runtime.Diagnostics.EventDescriptor(1416, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1417, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1418, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0xa00, 0x1000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1419, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0xa00, 0x1000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1422, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1423, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa00, 0x1000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1424, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa00, 0x1000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1430, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1433, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1438, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1432, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1431, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1439, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0xa00, 0x1000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1441, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1442, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0x9fe, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1443, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0x9fe, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1445, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1446, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(1451, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0xa00, 0x2000000000400000),
                    new System.Runtime.Diagnostics.EventDescriptor(3398, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9f8, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3399, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9f8, 0x1000000000001000),
                    new System.Runtime.Diagnostics.EventDescriptor(3405, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa37, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3406, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa37, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3401, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa33, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3402, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa33, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3403, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa36, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3404, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa36, 0x1000000000000010),
                    new System.Runtime.Diagnostics.EventDescriptor(3407, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa27, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3408, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa27, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3409, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0xa27, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3410, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0xa27, 0x2000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3411, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0x9d7, 0x2000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3412, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa28, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3413, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa28, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3414, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0xa28, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3415, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9d7, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3416, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9d7, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3417, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9d7, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3418, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9d7, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3419, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0x9d7, 0x2000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3420, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0x9d7, 0x2000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3421, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Error, (byte)TraceEventOpcode.Info, 0x9d7, 0x2000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3422, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa28, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3423, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0xa28, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3424, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa27, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3425, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0xa27, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3426, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9d7, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3427, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9d7, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3428, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9d7, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3429, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9d7, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3430, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9d7, 0x1000000000000100),
                    new System.Runtime.Diagnostics.EventDescriptor(3431, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9d7, 0x1000000000000100)};
            // The hashcodes calculated from PTCop for TD.CreateEventDescriptors are unstable when just declaring
            // a local field of ushort[] if the array is non-empty and contains more than 2 entries, because
            // the c#-compiler is using some private types for optimization. The type name follows the following pattern:
            // <PrivateImplementationDetails>{6BAE93FD-290B-4DE0-BCEE-366B30800FDF} (where the GUID is changing with every build)
            // To scope the change to unblock PTCop as much as possible we wrap the list of End2EndEvents in a List<ushort>
            System.Collections.Generic.List<ushort> e2eEvents = new System.Collections.Generic.List<ushort>(120);
            e2eEvents.Add(201);
            e2eEvents.Add(202);
            e2eEvents.Add(203);
            e2eEvents.Add(204);
            e2eEvents.Add(205);
            e2eEvents.Add(208);
            e2eEvents.Add(209);
            e2eEvents.Add(211);
            e2eEvents.Add(212);
            e2eEvents.Add(214);
            e2eEvents.Add(215);
            e2eEvents.Add(216);
            e2eEvents.Add(217);
            e2eEvents.Add(218);
            e2eEvents.Add(219);
            e2eEvents.Add(220);
            e2eEvents.Add(221);
            e2eEvents.Add(222);
            e2eEvents.Add(223);
            e2eEvents.Add(509);
            e2eEvents.Add(510);
            e2eEvents.Add(701);
            e2eEvents.Add(702);
            e2eEvents.Add(703);
            e2eEvents.Add(704);
            e2eEvents.Add(706);
            e2eEvents.Add(707);
            e2eEvents.Add(708);
            e2eEvents.Add(709);
            e2eEvents.Add(710);
            e2eEvents.Add(711);
            e2eEvents.Add(712);
            e2eEvents.Add(715);
            e2eEvents.Add(716);
            e2eEvents.Add(717);
            e2eEvents.Add(3300);
            e2eEvents.Add(3301);
            e2eEvents.Add(3302);
            e2eEvents.Add(3303);
            e2eEvents.Add(3309);
            e2eEvents.Add(3310);
            e2eEvents.Add(3311);
            e2eEvents.Add(3312);
            e2eEvents.Add(3313);
            e2eEvents.Add(3319);
            e2eEvents.Add(3320);
            e2eEvents.Add(3322);
            e2eEvents.Add(3323);
            e2eEvents.Add(3324);
            e2eEvents.Add(3325);
            e2eEvents.Add(3326);
            e2eEvents.Add(3327);
            e2eEvents.Add(3328);
            e2eEvents.Add(3329);
            e2eEvents.Add(3330);
            e2eEvents.Add(3331);
            e2eEvents.Add(3332);
            e2eEvents.Add(3333);
            e2eEvents.Add(3334);
            e2eEvents.Add(3335);
            e2eEvents.Add(3336);
            e2eEvents.Add(3337);
            e2eEvents.Add(3338);
            e2eEvents.Add(3340);
            e2eEvents.Add(3341);
            e2eEvents.Add(3342);
            e2eEvents.Add(3343);
            e2eEvents.Add(3347);
            e2eEvents.Add(3348);
            e2eEvents.Add(3349);
            e2eEvents.Add(3350);
            e2eEvents.Add(3354);
            e2eEvents.Add(3355);
            e2eEvents.Add(3356);
            e2eEvents.Add(3357);
            e2eEvents.Add(3358);
            e2eEvents.Add(3359);
            e2eEvents.Add(3360);
            e2eEvents.Add(3361);
            e2eEvents.Add(3362);
            e2eEvents.Add(3363);
            e2eEvents.Add(3367);
            e2eEvents.Add(3369);
            e2eEvents.Add(3370);
            e2eEvents.Add(3371);
            e2eEvents.Add(3372);
            e2eEvents.Add(3376);
            e2eEvents.Add(3385);
            e2eEvents.Add(3388);
            e2eEvents.Add(3389);
            e2eEvents.Add(3390);
            e2eEvents.Add(3392);
            e2eEvents.Add(3393);
            e2eEvents.Add(3394);
            e2eEvents.Add(3395);
            e2eEvents.Add(3396);
            e2eEvents.Add(3397);
            e2eEvents.Add(3401);
            e2eEvents.Add(3402);
            e2eEvents.Add(3403);
            e2eEvents.Add(3404);
            e2eEvents.Add(3405);
            e2eEvents.Add(3406);
            e2eEvents.Add(3407);
            e2eEvents.Add(3408);
            e2eEvents.Add(3409);
            e2eEvents.Add(3410);
            e2eEvents.Add(3411);
            e2eEvents.Add(3412);
            e2eEvents.Add(3413);
            e2eEvents.Add(3414);
            e2eEvents.Add(3415);
            e2eEvents.Add(3416);
            e2eEvents.Add(3417);
            e2eEvents.Add(3418);
            e2eEvents.Add(3419);
            e2eEvents.Add(3420);
            e2eEvents.Add(3421);
            e2eEvents.Add(3430);
            e2eEvents.Add(3431);
            FxTrace.UpdateEventDefinitions(descriptors, e2eEvents.ToArray());
            eventDescriptors = descriptors;
        }
        
        /// <summary>
        /// Ensures that the event descriptors array is initialized
        /// </summary>
        static void EnsureEventDescriptors()
        {
            if (eventDescriptorsCreated)
            {
                return;
            }
            System.Threading.Monitor.Enter(syncLock);
            try
            {
                if (eventDescriptorsCreated)
                {
                    return;
                }
                CreateEventDescriptors();
                eventDescriptorsCreated = true;
            }
            finally
            {
                System.Threading.Monitor.Exit(syncLock);
            }
        }
        
        /// <summary>
        /// Check if ETW tracing is enabled for the particular event
        /// </summary>
        /// <param name="eventIndex">The index of the event descriptor</param>
        static bool IsEtwEventEnabled(int eventIndex)
        {
            if (FxTrace.Trace.IsEtwProviderEnabled)
            {
                EnsureEventDescriptors();
                return FxTrace.IsEventEnabled(eventIndex);
            }
            return false;
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, string eventParam2, string eventParam3)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        /// <param name="eventParam4">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, string eventParam2, string eventParam3, string eventParam4)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        /// <param name="eventParam4">A parameter of the ETW event</param>>
        /// <param name="eventParam5">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, bool eventParam2, string eventParam3, string eventParam4, string eventParam5)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4, eventParam5);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        /// <param name="eventParam4">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, long eventParam2, string eventParam3, string eventParam4)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, string eventParam2)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        /// <param name="eventParam4">A parameter of the ETW event</param>>
        /// <param name="eventParam5">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, string eventParam2, string eventParam3, string eventParam4, string eventParam5)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4, eventParam5);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, System.Guid eventParam1, string eventParam2, string eventParam3)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        /// <param name="eventParam4">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, int eventParam1, int eventParam2, string eventParam3, string eventParam4)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, int eventParam1, string eventParam2, string eventParam3)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, int eventParam1, int eventParam2, string eventParam3)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, int eventParam2, string eventParam3)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, int eventParam1, string eventParam2)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, System.Guid eventParam2, string eventParam3)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        /// <param name="eventParam4">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, int eventParam1, string eventParam2, string eventParam3, string eventParam4)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        /// <param name="eventParam4">A parameter of the ETW event</param>>
        /// <param name="eventParam5">A parameter of the ETW event</param>>
        /// <param name="eventParam6">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwTransferEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, System.Guid eventParam1, string eventParam2, string eventParam3, string eventParam4, string eventParam5, string eventParam6)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteTransferEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4, eventParam5, eventParam6);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        /// <param name="eventParam4">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwTransferEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, System.Guid eventParam1, string eventParam2, string eventParam3, string eventParam4)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteTransferEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4);
        }
        
        /// <summary>
        /// Writes ETW trace event
        ///</summary>
        /// <param name="eventIndex">The index of the event descriptor</param>>
        /// <param name="eventParam0">A parameter of the ETW event</param>>
        /// <param name="eventParam1">A parameter of the ETW event</param>>
        /// <param name="eventParam2">A parameter of the ETW event</param>>
        /// <param name="eventParam3">A parameter of the ETW event</param>>
        // Critical = Calls SecurityCritical method EtwProvider.WriteEvent
        // Safe = We only allow setting of provider id from SecurityCritical code, access to EventDescriptors is SecurityCritical, and ETW limits buffer sizes.
        [System.Security.SecuritySafeCriticalAttribute()]
        static bool WriteEtwTransferEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, System.Guid eventParam1, string eventParam2, string eventParam3)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteTransferEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3);
        }
        
        /// <summary>
        /// write a trace source into the diagnostic trace
        /// </summary>
        /// <param name="eventIndex">The index of the event descriptor</param>
        /// <param name="description">The description to write</param>
        /// <param name="payload">The trace payload</param>
        // Critical = Calls SecurityCritical method EtwDiagnosticTrace.WriteTraceSource
        // Safe = We only allow setting of provider id from SecurityCritical code
        [System.Security.SecuritySafeCriticalAttribute()]
        static void WriteTraceSource(int eventIndex, string description, TracePayload payload)
        {
            EnsureEventDescriptors();
            FxTrace.Trace.WriteTraceSource(ref eventDescriptors[eventIndex], description, payload);
        }
    }
}