//------------------------------------------------------------------------------
// <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.Routing
{
    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.Routing.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=3800, Level=informational, Channel=debug
        /// </summary>
        internal static bool RoutingServiceClosingClientIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(0)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service is closing client '{0}'.
        /// Event description ID=3800, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: The Routing Service is closing client '{0}'.</param>
        internal static void RoutingServiceClosingClient(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(0))
            {
                TD.WriteEtwEvent(0, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceClosingClient", Culture), param0);
                TD.WriteTraceSource(0, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3801, Level=warning, Channel=debug
        /// </summary>
        internal static bool RoutingServiceChannelFaultedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning 
                        && (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(1)));
        }
        
        /// <summary>
        /// Gets trace definition like: Routing Service client '{0}' has faulted.
        /// Event description ID=3801, Level=warning, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Routing Service client '{0}' has faulted.</param>
        internal static void RoutingServiceChannelFaulted(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(1))
            {
                TD.WriteEtwEvent(1, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceWarningToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceChannelFaulted", Culture), param0);
                TD.WriteTraceSource(1, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3802, Level=informational, Channel=debug
        /// </summary>
        internal static bool RoutingServiceCompletingOneWayIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(2)));
        }
        
        /// <summary>
        /// Gets trace definition like: A Routing Service one way message is completing.
        /// Event description ID=3802, Level=informational, Channel=debug
        /// </summary>
        /// <param name="exception">Exception associated with the event</param>
        internal static void RoutingServiceCompletingOneWay(System.Exception exception)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            if (TD.IsEtwEventEnabled(2))
            {
                TD.WriteEtwEvent(2, null, payload.SerializedException, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceCompletingOneWay", Culture));
                TD.WriteTraceSource(2, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3807, Level=informational, Channel=debug
        /// </summary>
        internal static bool RoutingServiceCompletingTwoWayIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(3)));
        }
        
        /// <summary>
        /// Gets trace definition like: A Routing Service request reply message is completing.
        /// Event description ID=3807, Level=informational, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void RoutingServiceCompletingTwoWay(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(3))
            {
                TD.WriteEtwEvent(3, eventTraceActivity, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceCompletingTwoWay", Culture));
                TD.WriteTraceSource(3, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3803, Level=Error, Channel=debug
        /// </summary>
        internal static bool RoutingServiceProcessingFailureIsEnabled()
        {
            return (FxTrace.ShouldTraceError 
                        && (FxTrace.ShouldTraceErrorToTraceSource || TD.IsEtwEventEnabled(4)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service failed while processing a message on the endpoint with address '{0}'.
        /// Event description ID=3803, Level=Error, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: The Routing Service failed while processing a message on the endpoint with address '{0}'.</param>
        /// <param name="exception">Exception associated with the event</param>
        internal static void RoutingServiceProcessingFailure(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0, System.Exception exception)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            if (TD.IsEtwEventEnabled(4))
            {
                TD.WriteEtwEvent(4, eventTraceActivity, param0, payload.SerializedException, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceErrorToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceProcessingFailure", Culture), param0);
                TD.WriteTraceSource(4, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3804, Level=informational, Channel=debug
        /// </summary>
        internal static bool RoutingServiceCreatingClientForEndpointIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(5)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service is creating a client for endpoint: '{0}'.
        /// Event description ID=3804, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: The Routing Service is creating a client for endpoint: '{0}'.</param>
        internal static void RoutingServiceCreatingClientForEndpoint(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(5))
            {
                TD.WriteEtwEvent(5, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceCreatingClientForEndpoint", Culture), param0);
                TD.WriteTraceSource(5, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3805, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool RoutingServiceDisplayConfigIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(6)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service is configured with RouteOnHeadersOnly: {0}, SoapProcessingEnabled: {1}, EnsureOrderedDispatch: {2}.
        /// Event description ID=3805, Level=Verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: The Routing Service is configured with RouteOnHeadersOnly: {0}, SoapProcessingEnabled: {1}, EnsureOrderedDispatch: {2}.</param>
        /// <param name="param1">Parameter 1 for event: The Routing Service is configured with RouteOnHeadersOnly: {0}, SoapProcessingEnabled: {1}, EnsureOrderedDispatch: {2}.</param>
        /// <param name="param2">Parameter 2 for event: The Routing Service is configured with RouteOnHeadersOnly: {0}, SoapProcessingEnabled: {1}, EnsureOrderedDispatch: {2}.</param>
        internal static void RoutingServiceDisplayConfig(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(6))
            {
                TD.WriteEtwEvent(6, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceDisplayConfig", Culture), param0, param1, param2);
                TD.WriteTraceSource(6, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3809, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool RoutingServiceMessageRoutedToEndpointsIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(7)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service routed message with ID: '{0}' to {1} endpoint lists.
        /// Event description ID=3809, Level=Verbose, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: The Routing Service routed message with ID: '{0}' to {1} endpoint lists.</param>
        /// <param name="param1">Parameter 1 for event: The Routing Service routed message with ID: '{0}' to {1} endpoint lists.</param>
        internal static void RoutingServiceMessageRoutedToEndpoints(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0, string param1)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(7))
            {
                TD.WriteEtwEvent(7, eventTraceActivity, param0, param1, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceMessageRoutedToEndpoints", Culture), param0, param1);
                TD.WriteTraceSource(7, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3810, Level=informational, Channel=debug
        /// </summary>
        internal static bool RoutingServiceConfigurationAppliedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(8)));
        }
        
        /// <summary>
        /// Gets trace definition like: A new RoutingConfiguration has been applied to the Routing Service.
        /// Event description ID=3810, Level=informational, Channel=debug
        /// </summary>
        internal static void RoutingServiceConfigurationApplied()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(8))
            {
                TD.WriteEtwEvent(8, null, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceConfigurationApplied", Culture));
                TD.WriteTraceSource(8, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3815, Level=informational, Channel=debug
        /// </summary>
        internal static bool RoutingServiceProcessingMessageIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(9)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service is processing a message with ID: '{0}', Action: '{1}', Inbound URL: '{2}' Received in Transaction: {3}.
        /// Event description ID=3815, Level=informational, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: The Routing Service is processing a message with ID: '{0}', Action: '{1}', Inbound URL: '{2}' Received in Transaction: {3}.</param>
        /// <param name="param1">Parameter 1 for event: The Routing Service is processing a message with ID: '{0}', Action: '{1}', Inbound URL: '{2}' Received in Transaction: {3}.</param>
        /// <param name="param2">Parameter 2 for event: The Routing Service is processing a message with ID: '{0}', Action: '{1}', Inbound URL: '{2}' Received in Transaction: {3}.</param>
        /// <param name="param3">Parameter 3 for event: The Routing Service is processing a message with ID: '{0}', Action: '{1}', Inbound URL: '{2}' Received in Transaction: {3}.</param>
        internal static void RoutingServiceProcessingMessage(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0, string param1, string param2, string param3)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(9))
            {
                TD.WriteEtwEvent(9, eventTraceActivity, param0, param1, param2, param3, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceProcessingMessage", Culture), param0, param1, param2, param3);
                TD.WriteTraceSource(9, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3816, Level=informational, Channel=debug
        /// </summary>
        internal static bool RoutingServiceTransmittingMessageIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(10)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service is transmitting the message with ID: '{0}' [operation {1}] to '{2}'.
        /// Event description ID=3816, Level=informational, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: The Routing Service is transmitting the message with ID: '{0}' [operation {1}] to '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: The Routing Service is transmitting the message with ID: '{0}' [operation {1}] to '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: The Routing Service is transmitting the message with ID: '{0}' [operation {1}] to '{2}'.</param>
        internal static void RoutingServiceTransmittingMessage(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(10))
            {
                TD.WriteEtwEvent(10, eventTraceActivity, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceTransmittingMessage", Culture), param0, param1, param2);
                TD.WriteTraceSource(10, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3817, Level=informational, Channel=debug
        /// </summary>
        internal static bool RoutingServiceCommittingTransactionIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(11)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service is committing a transaction with id: '{0}'.
        /// Event description ID=3817, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: The Routing Service is committing a transaction with id: '{0}'.</param>
        internal static void RoutingServiceCommittingTransaction(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(11))
            {
                TD.WriteEtwEvent(11, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceCommittingTransaction", Culture), param0);
                TD.WriteTraceSource(11, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3818, Level=error, Channel=debug
        /// </summary>
        internal static bool RoutingServiceDuplexCallbackExceptionIsEnabled()
        {
            return (FxTrace.ShouldTraceError 
                        && (FxTrace.ShouldTraceErrorToTraceSource || TD.IsEtwEventEnabled(12)));
        }
        
        /// <summary>
        /// Gets trace definition like: Routing Service component {0} encountered a duplex callback exception.
        /// Event description ID=3818, Level=error, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: Routing Service component {0} encountered a duplex callback exception.</param>
        /// <param name="exception">Exception associated with the event</param>
        internal static void RoutingServiceDuplexCallbackException(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0, System.Exception exception)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            if (TD.IsEtwEventEnabled(12))
            {
                TD.WriteEtwEvent(12, eventTraceActivity, param0, payload.SerializedException, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceErrorToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceDuplexCallbackException", Culture), param0);
                TD.WriteTraceSource(12, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3819, Level=informational, Channel=debug
        /// </summary>
        internal static bool RoutingServiceMovedToBackupIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(13)));
        }
        
        /// <summary>
        /// Gets trace definition like: Routing Service message with ID: '{0}' [operation {1}] moved to backup endpoint '{2}'.
        /// Event description ID=3819, Level=informational, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: Routing Service message with ID: '{0}' [operation {1}] moved to backup endpoint '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: Routing Service message with ID: '{0}' [operation {1}] moved to backup endpoint '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: Routing Service message with ID: '{0}' [operation {1}] moved to backup endpoint '{2}'.</param>
        internal static void RoutingServiceMovedToBackup(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(13))
            {
                TD.WriteEtwEvent(13, eventTraceActivity, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceMovedToBackup", Culture), param0, param1, param2);
                TD.WriteTraceSource(13, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3820, Level=informational, Channel=debug
        /// </summary>
        internal static bool RoutingServiceCreatingTransactionIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(14)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service created a new Transaction with id '{0}' for processing message(s).
        /// Event description ID=3820, Level=informational, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: The Routing Service created a new Transaction with id '{0}' for processing message(s).</param>
        internal static void RoutingServiceCreatingTransaction(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(14))
            {
                TD.WriteEtwEvent(14, eventTraceActivity, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceCreatingTransaction", Culture), param0);
                TD.WriteTraceSource(14, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3821, Level=Warning, Channel=debug
        /// </summary>
        internal static bool RoutingServiceCloseFailedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning 
                        && (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(15)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service failed while closing outbound client '{0}'.
        /// Event description ID=3821, Level=Warning, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: The Routing Service failed while closing outbound client '{0}'.</param>
        /// <param name="exception">Exception associated with the event</param>
        internal static void RoutingServiceCloseFailed(string param0, System.Exception exception)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            if (TD.IsEtwEventEnabled(15))
            {
                TD.WriteEtwEvent(15, null, param0, payload.SerializedException, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceWarningToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceCloseFailed", Culture), param0);
                TD.WriteTraceSource(15, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3822, Level=informational, Channel=debug
        /// </summary>
        internal static bool RoutingServiceSendingResponseIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(16)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service is sending back a response message with Action '{0}'.
        /// Event description ID=3822, Level=informational, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: The Routing Service is sending back a response message with Action '{0}'.</param>
        internal static void RoutingServiceSendingResponse(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(16))
            {
                TD.WriteEtwEvent(16, eventTraceActivity, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceSendingResponse", Culture), param0);
                TD.WriteTraceSource(16, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3823, Level=Warning, Channel=debug
        /// </summary>
        internal static bool RoutingServiceSendingFaultResponseIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning 
                        && (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(17)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service is sending back a Fault response message with Action '{0}'.
        /// Event description ID=3823, Level=Warning, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: The Routing Service is sending back a Fault response message with Action '{0}'.</param>
        internal static void RoutingServiceSendingFaultResponse(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(17))
            {
                TD.WriteEtwEvent(17, eventTraceActivity, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceWarningToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceSendingFaultResponse", Culture), param0);
                TD.WriteTraceSource(17, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3824, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool RoutingServiceCompletingReceiveContextIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(18)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service is calling ReceiveContext.Complete for Message with ID: '{0}'.
        /// Event description ID=3824, Level=Verbose, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: The Routing Service is calling ReceiveContext.Complete for Message with ID: '{0}'.</param>
        internal static void RoutingServiceCompletingReceiveContext(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(18))
            {
                TD.WriteEtwEvent(18, eventTraceActivity, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceCompletingReceiveContext", Culture), param0);
                TD.WriteTraceSource(18, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3825, Level=Warning, Channel=debug
        /// </summary>
        internal static bool RoutingServiceAbandoningReceiveContextIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning 
                        && (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(19)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service is calling ReceiveContext.Abandon for Message with ID: '{0}'.
        /// Event description ID=3825, Level=Warning, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: The Routing Service is calling ReceiveContext.Abandon for Message with ID: '{0}'.</param>
        internal static void RoutingServiceAbandoningReceiveContext(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(19))
            {
                TD.WriteEtwEvent(19, eventTraceActivity, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceWarningToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceAbandoningReceiveContext", Culture), param0);
                TD.WriteTraceSource(19, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3826, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool RoutingServiceUsingExistingTransactionIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(20)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service will send messages using existing transaction '{0}'.
        /// Event description ID=3826, Level=Verbose, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: The Routing Service will send messages using existing transaction '{0}'.</param>
        internal static void RoutingServiceUsingExistingTransaction(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(20))
            {
                TD.WriteEtwEvent(20, eventTraceActivity, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceUsingExistingTransaction", Culture), param0);
                TD.WriteTraceSource(20, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3827, Level=Warning, Channel=debug
        /// </summary>
        internal static bool RoutingServiceTransmitFailedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning 
                        && (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(21)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service failed while sending to '{0}'.
        /// Event description ID=3827, Level=Warning, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: The Routing Service failed while sending to '{0}'.</param>
        /// <param name="exception">Exception associated with the event</param>
        internal static void RoutingServiceTransmitFailed(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0, System.Exception exception)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            if (TD.IsEtwEventEnabled(21))
            {
                TD.WriteEtwEvent(21, eventTraceActivity, param0, payload.SerializedException, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceWarningToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceTransmitFailed", Culture), param0);
                TD.WriteTraceSource(21, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3828, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool RoutingServiceFilterTableMatchStartIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(22));
        }
        
        /// <summary>
        /// Gets trace definition like: Routing Service MessageFilterTable Match Start.
        /// Event description ID=3828, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void RoutingServiceFilterTableMatchStart(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(22))
            {
                TD.WriteEtwEvent(22, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3829, Level=informational, Channel=Analytic
        /// </summary>
        internal static bool RoutingServiceFilterTableMatchStopIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation && TD.IsEtwEventEnabled(23));
        }
        
        /// <summary>
        /// Gets trace definition like: Routing Service MessageFilterTable Match Stop.
        /// Event description ID=3829, Level=informational, Channel=Analytic
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        internal static void RoutingServiceFilterTableMatchStop(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(23))
            {
                TD.WriteEtwEvent(23, eventTraceActivity, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3830, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool RoutingServiceAbortingChannelIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(24)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service is calling abort on channel: '{0}'.
        /// Event description ID=3830, Level=Verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: The Routing Service is calling abort on channel: '{0}'.</param>
        internal static void RoutingServiceAbortingChannel(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(24))
            {
                TD.WriteEtwEvent(24, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceAbortingChannel", Culture), param0);
                TD.WriteTraceSource(24, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3831, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool RoutingServiceHandledExceptionIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(25)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service has handled an exception.
        /// Event description ID=3831, Level=Verbose, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="exception">Exception associated with the event</param>
        internal static void RoutingServiceHandledException(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, System.Exception exception)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            if (TD.IsEtwEventEnabled(25))
            {
                TD.WriteEtwEvent(25, eventTraceActivity, payload.SerializedException, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceHandledException", Culture));
                TD.WriteTraceSource(25, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=3832, Level=Informational, Channel=debug
        /// </summary>
        internal static bool RoutingServiceTransmitSucceededIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(26)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Routing Service successfully transmitted Message with ID: '{0} [operation {1}] to '{2}'.
        /// Event description ID=3832, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="eventTraceActivity">The event trace activity</param>
        /// <param name="param0">Parameter 0 for event: The Routing Service successfully transmitted Message with ID: '{0} [operation {1}] to '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: The Routing Service successfully transmitted Message with ID: '{0} [operation {1}] to '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: The Routing Service successfully transmitted Message with ID: '{0} [operation {1}] to '{2}'.</param>
        internal static void RoutingServiceTransmitSucceeded(System.Runtime.Diagnostics.EventTraceActivity eventTraceActivity, string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(26))
            {
                TD.WriteEtwEvent(26, eventTraceActivity, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RoutingServiceTransmitSucceeded", Culture), param0, param1, param2);
                TD.WriteTraceSource(26, description, payload);
            }
        }
        
        /// <summary>
        /// Creates the event descriptors array
        /// </summary>
        static void CreateEventDescriptors()
        {
            System.Runtime.Diagnostics.EventDescriptor[] descriptors = new System.Runtime.Diagnostics.EventDescriptor[] {
                    new System.Runtime.Diagnostics.EventDescriptor(3800, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)87, 0xa03, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3801, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)86, 0xa03, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3802, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)89, 0xa05, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3807, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)90, 0xa05, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3803, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Error, (byte)92, 0xa05, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3804, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)88, 0xa03, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3805, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa05, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3809, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)94, 0xa05, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3810, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)82, 0xa02, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3815, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)93, 0xa05, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3816, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)98, 0xa05, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3817, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)101, 0xa07, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3818, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Error, (byte)83, 0xa02, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3819, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)91, 0xa05, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3820, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)102, 0xa07, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3821, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)81, 0xa02, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3822, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)96, 0xa05, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3823, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)95, 0xa05, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3824, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)100, 0xa06, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3825, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)99, 0xa06, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3826, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)103, 0xa07, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3827, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)85, 0xa02, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3828, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Start, 0xa04, 0x2000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3829, 0, (byte)TraceChannel.Analytic, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0xa04, 0x2000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3830, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)80, 0xa02, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3831, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)84, 0xa02, 0x1000000000008000),
                    new System.Runtime.Diagnostics.EventDescriptor(3832, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)97, 0xa05, 0x1000000000008000)};
            ushort[] e2eEvents = new ushort[] {
                    3803,
                    3807,
                    3809,
                    3815,
                    3816,
                    3818,
                    3819,
                    3820,
                    3822,
                    3823,
                    3824,
                    3825,
                    3826,
                    3827,
                    3828,
                    3829,
                    3831,
                    3832};
            FxTrace.UpdateEventDefinitions(descriptors, e2eEvents);
            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>>
        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>>
        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>>
        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>>
        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>>
        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>
        /// 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>
        static void WriteTraceSource(int eventIndex, string description, TracePayload payload)
        {
            EnsureEventDescriptors();
            FxTrace.Trace.WriteTraceSource(ref eventDescriptors[eventIndex], description, payload);
        }
    }
}