//------------------------------------------------------------------------------
// <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.Activities
{
    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.Activities.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=39456, Level=Warning, Channel=debug
        /// </summary>
        internal static bool TrackingRecordDroppedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(0));
        }
        
        /// <summary>
        /// Gets trace definition like: Size of tracking record {0} exceeds maximum allowed by the ETW session for provider {1}
        /// Event description ID=39456, Level=Warning, Channel=debug
        /// </summary>
        /// <param name="RecordNumber">Parameter 0 for event: Size of tracking record {0} exceeds maximum allowed by the ETW session for provider {1}</param>
        /// <param name="ProviderId">Parameter 1 for event: Size of tracking record {0} exceeds maximum allowed by the ETW session for provider {1}</param>
        internal static void TrackingRecordDropped(long RecordNumber, System.Guid ProviderId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(0))
            {
                TD.WriteEtwEvent(0, null, RecordNumber, ProviderId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=39457, Level=informational, Channel=debug
        /// </summary>
        internal static bool TrackingRecordRaisedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(1)));
        }
        
        /// <summary>
        /// Gets trace definition like: Tracking Record {0} raised to {1}.
        /// Event description ID=39457, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Tracking Record {0} raised to {1}.</param>
        /// <param name="param1">Parameter 1 for event: Tracking Record {0} raised to {1}.</param>
        internal static void TrackingRecordRaised(string param0, string param1)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(1))
            {
                TD.WriteEtwEvent(1, null, param0, param1, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("TrackingRecordRaised", Culture), param0, param1);
                TD.WriteTraceSource(1, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=39458, Level=Warning, Channel=debug
        /// </summary>
        internal static bool TrackingRecordTruncatedIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(2));
        }
        
        /// <summary>
        /// Gets trace definition like: Truncated tracking record {0} written to ETW session with provider {1}. Variables/annotations/user data have been removed
        /// Event description ID=39458, Level=Warning, Channel=debug
        /// </summary>
        /// <param name="RecordNumber">Parameter 0 for event: Truncated tracking record {0} written to ETW session with provider {1}. Variables/annotations/user data have been removed</param>
        /// <param name="ProviderId">Parameter 1 for event: Truncated tracking record {0} written to ETW session with provider {1}. Variables/annotations/user data have been removed</param>
        internal static void TrackingRecordTruncated(long RecordNumber, System.Guid ProviderId)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(2))
            {
                TD.WriteEtwEvent(2, null, RecordNumber, ProviderId, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=39459, Level=verbose, Channel=debug
        /// </summary>
        internal static bool TrackingDataExtractedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(3)));
        }
        
        /// <summary>
        /// Gets trace definition like: Tracking data {0} extracted in activity {1}.
        /// Event description ID=39459, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="Data">Parameter 0 for event: Tracking data {0} extracted in activity {1}.</param>
        /// <param name="Activity">Parameter 1 for event: Tracking data {0} extracted in activity {1}.</param>
        internal static void TrackingDataExtracted(string Data, string Activity)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(3))
            {
                TD.WriteEtwEvent(3, null, Data, Activity, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("TrackingDataExtracted", Culture), Data, Activity);
                TD.WriteTraceSource(3, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1223, Level=Informational, Channel=debug
        /// </summary>
        internal static bool SwitchCaseNotFoundIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(4)));
        }
        
        /// <summary>
        /// Gets trace definition like: The Switch activity '{0}' could not find a Case activity matching the Expression result.
        /// Event description ID=1223, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: The Switch activity '{0}' could not find a Case activity matching the Expression result.</param>
        internal static void SwitchCaseNotFound(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(4))
            {
                TD.WriteEtwEvent(4, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("SwitchCaseNotFound", Culture), param0);
                TD.WriteTraceSource(4, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=2576, Level=Informational, Channel=debug
        /// </summary>
        internal static bool TryCatchExceptionFromTryIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(5)));
        }
        
        /// <summary>
        /// Gets trace definition like: The TryCatch activity '{0}' has caught an exception of type '{1}'.
        /// Event description ID=2576, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: The TryCatch activity '{0}' has caught an exception of type '{1}'.</param>
        /// <param name="param1">Parameter 1 for event: The TryCatch activity '{0}' has caught an exception of type '{1}'.</param>
        internal static void TryCatchExceptionFromTry(string param0, string param1)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(5))
            {
                TD.WriteEtwEvent(5, null, param0, param1, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("TryCatchExceptionFromTry", Culture), param0, param1);
                TD.WriteTraceSource(5, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=2577, Level=Warning, Channel=debug
        /// </summary>
        internal static bool TryCatchExceptionDuringCancelationIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning 
                        && (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(6)));
        }
        
        /// <summary>
        /// Gets trace definition like: A child activity of the TryCatch activity '{0}' has thrown an exception during cancelation.
        /// Event description ID=2577, Level=Warning, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A child activity of the TryCatch activity '{0}' has thrown an exception during cancelation.</param>
        internal static void TryCatchExceptionDuringCancelation(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(6))
            {
                TD.WriteEtwEvent(6, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceWarningToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("TryCatchExceptionDuringCancelation", Culture), param0);
                TD.WriteTraceSource(6, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=2578, Level=Warning, Channel=debug
        /// </summary>
        internal static bool TryCatchExceptionFromCatchOrFinallyIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning 
                        && (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(7)));
        }
        
        /// <summary>
        /// Gets trace definition like: A Catch or Finally activity that is associated with the TryCatch activity '{0}' has thrown an exception.
        /// Event description ID=2578, Level=Warning, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A Catch or Finally activity that is associated with the TryCatch activity '{0}' has thrown an exception.</param>
        internal static void TryCatchExceptionFromCatchOrFinally(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(7))
            {
                TD.WriteEtwEvent(7, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceWarningToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("TryCatchExceptionFromCatchOrFinally", Culture), param0);
                TD.WriteTraceSource(7, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1023, Level=verbose, Channel=debug
        /// </summary>
        internal static bool CompleteBookmarkWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(8)));
        }
        
        /// <summary>
        /// Gets trace definition like: A BookmarkWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.
        /// Event description ID=1023, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A BookmarkWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param1">Parameter 1 for event: A BookmarkWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param2">Parameter 2 for event: A BookmarkWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param3">Parameter 3 for event: A BookmarkWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param4">Parameter 4 for event: A BookmarkWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. BookmarkName: {3}, BookmarkScope: {4}.</param>
        internal static void CompleteBookmarkWorkItem(string param0, string param1, string param2, string param3, string param4)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(8))
            {
                TD.WriteEtwEvent(8, null, param0, param1, param2, param3, param4, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("CompleteBookmarkWorkItem", Culture), param0, param1, param2, param3, param4);
                TD.WriteTraceSource(8, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1019, Level=verbose, Channel=debug
        /// </summary>
        internal static bool CompleteCancelActivityWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(9)));
        }
        
        /// <summary>
        /// Gets trace definition like: A CancelActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
        /// Event description ID=1019, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A CancelActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: A CancelActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: A CancelActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        internal static void CompleteCancelActivityWorkItem(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(9))
            {
                TD.WriteEtwEvent(9, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("CompleteCancelActivityWorkItem", Culture), param0, param1, param2);
                TD.WriteTraceSource(9, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1016, Level=verbose, Channel=debug
        /// </summary>
        internal static bool CompleteCompletionWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(10)));
        }
        
        /// <summary>
        /// Gets trace definition like: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
        /// Event description ID=1016, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param1">Parameter 1 for event: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param2">Parameter 2 for event: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param3">Parameter 3 for event: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param4">Parameter 4 for event: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param5">Parameter 5 for event: A CompletionWorkItem has completed for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        internal static void CompleteCompletionWorkItem(string param0, string param1, string param2, string param3, string param4, string param5)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(10))
            {
                TD.WriteEtwEvent(10, null, param0, param1, param2, param3, param4, param5, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("CompleteCompletionWorkItem", Culture), param0, param1, param2, param3, param4, param5);
                TD.WriteTraceSource(10, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1013, Level=verbose, Channel=debug
        /// </summary>
        internal static bool CompleteExecuteActivityWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(11)));
        }
        
        /// <summary>
        /// Gets trace definition like: An ExecuteActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
        /// Event description ID=1013, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: An ExecuteActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: An ExecuteActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: An ExecuteActivityWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        internal static void CompleteExecuteActivityWorkItem(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(11))
            {
                TD.WriteEtwEvent(11, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("CompleteExecuteActivityWorkItem", Culture), param0, param1, param2);
                TD.WriteTraceSource(11, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1031, Level=verbose, Channel=debug
        /// </summary>
        internal static bool CompleteFaultWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(12)));
        }
        
        /// <summary>
        /// Gets trace definition like: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
        /// Event description ID=1031, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param1">Parameter 1 for event: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param2">Parameter 2 for event: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param3">Parameter 3 for event: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param4">Parameter 4 for event: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param5">Parameter 5 for event: A FaultWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="exception">Exception associated with the event</param>
        internal static void CompleteFaultWorkItem(string param0, string param1, string param2, string param3, string param4, string param5, System.Exception exception)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            if (TD.IsEtwEventEnabled(12))
            {
                TD.WriteEtwEvent(12, null, param0, param1, param2, param3, param4, param5, payload.SerializedException, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("CompleteFaultWorkItem", Culture), param0, param1, param2, param3, param4, param5);
                TD.WriteTraceSource(12, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1034, Level=verbose, Channel=debug
        /// </summary>
        internal static bool CompleteRuntimeWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(13)));
        }
        
        /// <summary>
        /// Gets trace definition like: A runtime work item has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
        /// Event description ID=1034, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A runtime work item has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: A runtime work item has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: A runtime work item has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        internal static void CompleteRuntimeWorkItem(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(13))
            {
                TD.WriteEtwEvent(13, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("CompleteRuntimeWorkItem", Culture), param0, param1, param2);
                TD.WriteTraceSource(13, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1028, Level=verbose, Channel=debug
        /// </summary>
        internal static bool CompleteTransactionContextWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(14)));
        }
        
        /// <summary>
        /// Gets trace definition like: A TransactionContextWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
        /// Event description ID=1028, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A TransactionContextWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: A TransactionContextWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: A TransactionContextWorkItem has completed for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        internal static void CompleteTransactionContextWorkItem(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(14))
            {
                TD.WriteEtwEvent(14, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("CompleteTransactionContextWorkItem", Culture), param0, param1, param2);
                TD.WriteTraceSource(14, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1020, Level=verbose, Channel=debug
        /// </summary>
        internal static bool CreateBookmarkIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(15)));
        }
        
        /// <summary>
        /// Gets trace definition like: A Bookmark has been created for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.
        /// Event description ID=1020, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A Bookmark has been created for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param1">Parameter 1 for event: A Bookmark has been created for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param2">Parameter 2 for event: A Bookmark has been created for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param3">Parameter 3 for event: A Bookmark has been created for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param4">Parameter 4 for event: A Bookmark has been created for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        internal static void CreateBookmark(string param0, string param1, string param2, string param3, string param4)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(15))
            {
                TD.WriteEtwEvent(15, null, param0, param1, param2, param3, param4, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("CreateBookmark", Culture), param0, param1, param2, param3, param4);
                TD.WriteTraceSource(15, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1024, Level=verbose, Channel=debug
        /// </summary>
        internal static bool CreateBookmarkScopeIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(16)));
        }
        
        /// <summary>
        /// Gets trace definition like: A BookmarkScope has been created: {0}.
        /// Event description ID=1024, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A BookmarkScope has been created: {0}.</param>
        internal static void CreateBookmarkScope(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(16))
            {
                TD.WriteEtwEvent(16, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("CreateBookmarkScope", Culture), param0);
                TD.WriteTraceSource(16, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1038, Level=verbose, Channel=debug
        /// </summary>
        internal static bool EnterNoPersistBlockIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(17)));
        }
        
        /// <summary>
        /// Gets trace definition like: Entering a no persist block.
        /// Event description ID=1038, Level=verbose, Channel=debug
        /// </summary>
        internal static void EnterNoPersistBlock()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(17))
            {
                TD.WriteEtwEvent(17, null, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("EnterNoPersistBlock", Culture));
                TD.WriteTraceSource(17, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1039, Level=verbose, Channel=debug
        /// </summary>
        internal static bool ExitNoPersistBlockIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(18)));
        }
        
        /// <summary>
        /// Gets trace definition like: Exiting a no persist block.
        /// Event description ID=1039, Level=verbose, Channel=debug
        /// </summary>
        internal static void ExitNoPersistBlock()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(18))
            {
                TD.WriteEtwEvent(18, null, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ExitNoPersistBlock", Culture));
                TD.WriteTraceSource(18, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1040, Level=verbose, Channel=debug
        /// </summary>
        internal static bool InArgumentBoundIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(19)));
        }
        
        /// <summary>
        /// Gets trace definition like: In argument '{0}' on Activity '{1}', DisplayName: '{2}', InstanceId: '{3}' has been bound with value: {4}.
        /// Event description ID=1040, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: In argument '{0}' on Activity '{1}', DisplayName: '{2}', InstanceId: '{3}' has been bound with value: {4}.</param>
        /// <param name="param1">Parameter 1 for event: In argument '{0}' on Activity '{1}', DisplayName: '{2}', InstanceId: '{3}' has been bound with value: {4}.</param>
        /// <param name="param2">Parameter 2 for event: In argument '{0}' on Activity '{1}', DisplayName: '{2}', InstanceId: '{3}' has been bound with value: {4}.</param>
        /// <param name="param3">Parameter 3 for event: In argument '{0}' on Activity '{1}', DisplayName: '{2}', InstanceId: '{3}' has been bound with value: {4}.</param>
        /// <param name="param4">Parameter 4 for event: In argument '{0}' on Activity '{1}', DisplayName: '{2}', InstanceId: '{3}' has been bound with value: {4}.</param>
        internal static void InArgumentBound(string param0, string param1, string param2, string param3, string param4)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(19))
            {
                TD.WriteEtwEvent(19, null, param0, param1, param2, param3, param4, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("InArgumentBound", Culture), param0, param1, param2, param3, param4);
                TD.WriteTraceSource(19, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1037, Level=verbose, Channel=debug
        /// </summary>
        internal static bool RuntimeTransactionCompleteIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(20)));
        }
        
        /// <summary>
        /// Gets trace definition like: The runtime transaction has completed with the state '{0}'.
        /// Event description ID=1037, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: The runtime transaction has completed with the state '{0}'.</param>
        internal static void RuntimeTransactionComplete(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(20))
            {
                TD.WriteEtwEvent(20, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RuntimeTransactionComplete", Culture), param0);
                TD.WriteTraceSource(20, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1036, Level=verbose, Channel=debug
        /// </summary>
        internal static bool RuntimeTransactionCompletionRequestedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(21)));
        }
        
        /// <summary>
        /// Gets trace definition like: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has scheduled completion of the runtime transaction.
        /// Event description ID=1036, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has scheduled completion of the runtime transaction.</param>
        /// <param name="param1">Parameter 1 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has scheduled completion of the runtime transaction.</param>
        /// <param name="param2">Parameter 2 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has scheduled completion of the runtime transaction.</param>
        internal static void RuntimeTransactionCompletionRequested(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(21))
            {
                TD.WriteEtwEvent(21, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RuntimeTransactionCompletionRequested", Culture), param0, param1, param2);
                TD.WriteTraceSource(21, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1035, Level=verbose, Channel=debug
        /// </summary>
        internal static bool RuntimeTransactionSetIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(22)));
        }
        
        /// <summary>
        /// Gets trace definition like: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
        /// Event description ID=1035, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param1">Parameter 1 for event: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param2">Parameter 2 for event: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param3">Parameter 3 for event: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param4">Parameter 4 for event: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param5">Parameter 5 for event: The runtime transaction has been set by Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Execution isolated to Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        internal static void RuntimeTransactionSet(string param0, string param1, string param2, string param3, string param4, string param5)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(22))
            {
                TD.WriteEtwEvent(22, null, param0, param1, param2, param3, param4, param5, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("RuntimeTransactionSet", Culture), param0, param1, param2, param3, param4, param5);
                TD.WriteTraceSource(22, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1021, Level=verbose, Channel=debug
        /// </summary>
        internal static bool ScheduleBookmarkWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(23)));
        }
        
        /// <summary>
        /// Gets trace definition like: A BookmarkWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.
        /// Event description ID=1021, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A BookmarkWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param1">Parameter 1 for event: A BookmarkWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param2">Parameter 2 for event: A BookmarkWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param3">Parameter 3 for event: A BookmarkWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param4">Parameter 4 for event: A BookmarkWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        internal static void ScheduleBookmarkWorkItem(string param0, string param1, string param2, string param3, string param4)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(23))
            {
                TD.WriteEtwEvent(23, null, param0, param1, param2, param3, param4, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ScheduleBookmarkWorkItem", Culture), param0, param1, param2, param3, param4);
                TD.WriteTraceSource(23, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1017, Level=verbose, Channel=debug
        /// </summary>
        internal static bool ScheduleCancelActivityWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(24)));
        }
        
        /// <summary>
        /// Gets trace definition like: A CancelActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
        /// Event description ID=1017, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A CancelActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: A CancelActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: A CancelActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        internal static void ScheduleCancelActivityWorkItem(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(24))
            {
                TD.WriteEtwEvent(24, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ScheduleCancelActivityWorkItem", Culture), param0, param1, param2);
                TD.WriteTraceSource(24, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1014, Level=verbose, Channel=debug
        /// </summary>
        internal static bool ScheduleCompletionWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(25)));
        }
        
        /// <summary>
        /// Gets trace definition like: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
        /// Event description ID=1014, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param1">Parameter 1 for event: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param2">Parameter 2 for event: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param3">Parameter 3 for event: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param4">Parameter 4 for event: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param5">Parameter 5 for event: A CompletionWorkItem has been scheduled for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        internal static void ScheduleCompletionWorkItem(string param0, string param1, string param2, string param3, string param4, string param5)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(25))
            {
                TD.WriteEtwEvent(25, null, param0, param1, param2, param3, param4, param5, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ScheduleCompletionWorkItem", Culture), param0, param1, param2, param3, param4, param5);
                TD.WriteTraceSource(25, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1011, Level=verbose, Channel=debug
        /// </summary>
        internal static bool ScheduleExecuteActivityWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(26)));
        }
        
        /// <summary>
        /// Gets trace definition like: An ExecuteActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
        /// Event description ID=1011, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: An ExecuteActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: An ExecuteActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: An ExecuteActivityWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        internal static void ScheduleExecuteActivityWorkItem(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(26))
            {
                TD.WriteEtwEvent(26, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ScheduleExecuteActivityWorkItem", Culture), param0, param1, param2);
                TD.WriteTraceSource(26, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1029, Level=verbose, Channel=debug
        /// </summary>
        internal static bool ScheduleFaultWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(27)));
        }
        
        /// <summary>
        /// Gets trace definition like: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
        /// Event description ID=1029, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param1">Parameter 1 for event: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param2">Parameter 2 for event: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param3">Parameter 3 for event: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param4">Parameter 4 for event: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param5">Parameter 5 for event: A FaultWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="exception">Exception associated with the event</param>
        internal static void ScheduleFaultWorkItem(string param0, string param1, string param2, string param3, string param4, string param5, System.Exception exception)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            if (TD.IsEtwEventEnabled(27))
            {
                TD.WriteEtwEvent(27, null, param0, param1, param2, param3, param4, param5, payload.SerializedException, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ScheduleFaultWorkItem", Culture), param0, param1, param2, param3, param4, param5);
                TD.WriteTraceSource(27, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1032, Level=verbose, Channel=debug
        /// </summary>
        internal static bool ScheduleRuntimeWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(28)));
        }
        
        /// <summary>
        /// Gets trace definition like: A runtime work item has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
        /// Event description ID=1032, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A runtime work item has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: A runtime work item has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: A runtime work item has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        internal static void ScheduleRuntimeWorkItem(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(28))
            {
                TD.WriteEtwEvent(28, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ScheduleRuntimeWorkItem", Culture), param0, param1, param2);
                TD.WriteTraceSource(28, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1026, Level=verbose, Channel=debug
        /// </summary>
        internal static bool ScheduleTransactionContextWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(29)));
        }
        
        /// <summary>
        /// Gets trace definition like: A TransactionContextWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
        /// Event description ID=1026, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: A TransactionContextWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: A TransactionContextWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: A TransactionContextWorkItem has been scheduled for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        internal static void ScheduleTransactionContextWorkItem(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(29))
            {
                TD.WriteEtwEvent(29, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ScheduleTransactionContextWorkItem", Culture), param0, param1, param2);
                TD.WriteTraceSource(29, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1022, Level=verbose, Channel=debug
        /// </summary>
        internal static bool StartBookmarkWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(30)));
        }
        
        /// <summary>
        /// Gets trace definition like: Starting execution of a BookmarkWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.
        /// Event description ID=1022, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Starting execution of a BookmarkWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param1">Parameter 1 for event: Starting execution of a BookmarkWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param2">Parameter 2 for event: Starting execution of a BookmarkWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param3">Parameter 3 for event: Starting execution of a BookmarkWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        /// <param name="param4">Parameter 4 for event: Starting execution of a BookmarkWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  BookmarkName: {3}, BookmarkScope: {4}.</param>
        internal static void StartBookmarkWorkItem(string param0, string param1, string param2, string param3, string param4)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(30))
            {
                TD.WriteEtwEvent(30, null, param0, param1, param2, param3, param4, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("StartBookmarkWorkItem", Culture), param0, param1, param2, param3, param4);
                TD.WriteTraceSource(30, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1018, Level=verbose, Channel=debug
        /// </summary>
        internal static bool StartCancelActivityWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(31)));
        }
        
        /// <summary>
        /// Gets trace definition like: Starting execution of a CancelActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
        /// Event description ID=1018, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Starting execution of a CancelActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: Starting execution of a CancelActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: Starting execution of a CancelActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        internal static void StartCancelActivityWorkItem(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(31))
            {
                TD.WriteEtwEvent(31, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("StartCancelActivityWorkItem", Culture), param0, param1, param2);
                TD.WriteTraceSource(31, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1015, Level=verbose, Channel=debug
        /// </summary>
        internal static bool StartCompletionWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(32)));
        }
        
        /// <summary>
        /// Gets trace definition like: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
        /// Event description ID=1015, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param1">Parameter 1 for event: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param2">Parameter 2 for event: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param3">Parameter 3 for event: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param4">Parameter 4 for event: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param5">Parameter 5 for event: Starting execution of a CompletionWorkItem for parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'. Completed Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        internal static void StartCompletionWorkItem(string param0, string param1, string param2, string param3, string param4, string param5)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(32))
            {
                TD.WriteEtwEvent(32, null, param0, param1, param2, param3, param4, param5, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("StartCompletionWorkItem", Culture), param0, param1, param2, param3, param4, param5);
                TD.WriteTraceSource(32, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1012, Level=verbose, Channel=debug
        /// </summary>
        internal static bool StartExecuteActivityWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(33)));
        }
        
        /// <summary>
        /// Gets trace definition like: Starting execution of an ExecuteActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
        /// Event description ID=1012, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Starting execution of an ExecuteActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: Starting execution of an ExecuteActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: Starting execution of an ExecuteActivityWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        internal static void StartExecuteActivityWorkItem(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(33))
            {
                TD.WriteEtwEvent(33, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("StartExecuteActivityWorkItem", Culture), param0, param1, param2);
                TD.WriteTraceSource(33, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1030, Level=verbose, Channel=debug
        /// </summary>
        internal static bool StartFaultWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(34)));
        }
        
        /// <summary>
        /// Gets trace definition like: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
        /// Event description ID=1030, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param1">Parameter 1 for event: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param2">Parameter 2 for event: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param3">Parameter 3 for event: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param4">Parameter 4 for event: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param5">Parameter 5 for event: Starting execution of a FaultWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.  The exception was propagated from Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="exception">Exception associated with the event</param>
        internal static void StartFaultWorkItem(string param0, string param1, string param2, string param3, string param4, string param5, System.Exception exception)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            if (TD.IsEtwEventEnabled(34))
            {
                TD.WriteEtwEvent(34, null, param0, param1, param2, param3, param4, param5, payload.SerializedException, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("StartFaultWorkItem", Culture), param0, param1, param2, param3, param4, param5);
                TD.WriteTraceSource(34, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1033, Level=verbose, Channel=debug
        /// </summary>
        internal static bool StartRuntimeWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(35)));
        }
        
        /// <summary>
        /// Gets trace definition like: Starting execution of a runtime work item for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
        /// Event description ID=1033, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Starting execution of a runtime work item for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: Starting execution of a runtime work item for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: Starting execution of a runtime work item for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        internal static void StartRuntimeWorkItem(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(35))
            {
                TD.WriteEtwEvent(35, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("StartRuntimeWorkItem", Culture), param0, param1, param2);
                TD.WriteTraceSource(35, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1027, Level=verbose, Channel=debug
        /// </summary>
        internal static bool StartTransactionContextWorkItemIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(36)));
        }
        
        /// <summary>
        /// Gets trace definition like: Starting execution of a TransactionContextWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.
        /// Event description ID=1027, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Starting execution of a TransactionContextWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: Starting execution of a TransactionContextWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: Starting execution of a TransactionContextWorkItem for Activity '{0}', DisplayName: '{1}', InstanceId: '{2}'.</param>
        internal static void StartTransactionContextWorkItem(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(36))
            {
                TD.WriteEtwEvent(36, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("StartTransactionContextWorkItem", Culture), param0, param1, param2);
                TD.WriteTraceSource(36, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1025, Level=verbose, Channel=debug
        /// </summary>
        internal static bool BookmarkScopeInitializedIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose 
                        && (FxTrace.ShouldTraceVerboseToTraceSource || TD.IsEtwEventEnabled(37)));
        }
        
        /// <summary>
        /// Gets trace definition like: The BookmarkScope that had TemporaryId: '{0}' has been initialized with Id: '{1}'.
        /// Event description ID=1025, Level=verbose, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: The BookmarkScope that had TemporaryId: '{0}' has been initialized with Id: '{1}'.</param>
        /// <param name="param1">Parameter 1 for event: The BookmarkScope that had TemporaryId: '{0}' has been initialized with Id: '{1}'.</param>
        internal static void BookmarkScopeInitialized(string param0, string param1)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(37))
            {
                TD.WriteEtwEvent(37, null, param0, param1, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceVerboseToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("BookmarkScopeInitialized", Culture), param0, param1);
                TD.WriteTraceSource(37, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1104, Level=informational, Channel=debug
        /// </summary>
        internal static bool WorkflowActivityResumeIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(38)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowInstance Id: '{0}' E2E Activity
        /// Event description ID=1104, Level=informational, Channel=debug
        /// </summary>
        /// <param name="Id">Parameter 0 for event: WorkflowInstance Id: '{0}' E2E Activity</param>
        internal static void WorkflowActivityResume(System.Guid Id)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(38))
            {
                TD.WriteEtwEvent(38, null, Id, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowActivityResume", Culture), Id);
                TD.WriteTraceSource(38, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1101, Level=informational, Channel=debug
        /// </summary>
        internal static bool WorkflowActivityStartIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(39)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowInstance Id: '{0}' E2E Activity
        /// Event description ID=1101, Level=informational, Channel=debug
        /// </summary>
        /// <param name="Id">Parameter 0 for event: WorkflowInstance Id: '{0}' E2E Activity</param>
        internal static void WorkflowActivityStart(System.Guid Id)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(39))
            {
                TD.WriteEtwEvent(39, null, Id, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowActivityStart", Culture), Id);
                TD.WriteTraceSource(39, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1102, Level=informational, Channel=debug
        /// </summary>
        internal static bool WorkflowActivityStopIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(40)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowInstance Id: '{0}' E2E Activity
        /// Event description ID=1102, Level=informational, Channel=debug
        /// </summary>
        /// <param name="Id">Parameter 0 for event: WorkflowInstance Id: '{0}' E2E Activity</param>
        internal static void WorkflowActivityStop(System.Guid Id)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(40))
            {
                TD.WriteEtwEvent(40, null, Id, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowActivityStop", Culture), Id);
                TD.WriteTraceSource(40, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1103, Level=informational, Channel=debug
        /// </summary>
        internal static bool WorkflowActivitySuspendIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(41)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowInstance Id: '{0}' E2E Activity
        /// Event description ID=1103, Level=informational, Channel=debug
        /// </summary>
        /// <param name="Id">Parameter 0 for event: WorkflowInstance Id: '{0}' E2E Activity</param>
        internal static void WorkflowActivitySuspend(System.Guid Id)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(41))
            {
                TD.WriteEtwEvent(41, null, Id, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowActivitySuspend", Culture), Id);
                TD.WriteTraceSource(41, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1010, Level=informational, Channel=debug
        /// </summary>
        internal static bool ActivityCompletedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(42)));
        }
        
        /// <summary>
        /// Gets trace definition like: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has completed in the '{3}' state.
        /// Event description ID=1010, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has completed in the '{3}' state.</param>
        /// <param name="param1">Parameter 1 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has completed in the '{3}' state.</param>
        /// <param name="param2">Parameter 2 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has completed in the '{3}' state.</param>
        /// <param name="param3">Parameter 3 for event: Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' has completed in the '{3}' state.</param>
        internal static void ActivityCompleted(string param0, string param1, string param2, string param3)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(42))
            {
                TD.WriteEtwEvent(42, null, param0, param1, param2, param3, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ActivityCompleted", Culture), param0, param1, param2, param3);
                TD.WriteTraceSource(42, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1009, Level=informational, Channel=debug
        /// </summary>
        internal static bool ActivityScheduledIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(43)));
        }
        
        /// <summary>
        /// Gets trace definition like: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.
        /// Event description ID=1009, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param1">Parameter 1 for event: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param2">Parameter 2 for event: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param3">Parameter 3 for event: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param4">Parameter 4 for event: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        /// <param name="param5">Parameter 5 for event: Parent Activity '{0}', DisplayName: '{1}', InstanceId: '{2}' scheduled child Activity '{3}', DisplayName: '{4}', InstanceId: '{5}'.</param>
        internal static void ActivityScheduled(string param0, string param1, string param2, string param3, string param4, string param5)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(43))
            {
                TD.WriteEtwEvent(43, null, param0, param1, param2, param3, param4, param5, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("ActivityScheduled", Culture), param0, param1, param2, param3, param4, param5);
                TD.WriteTraceSource(43, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1004, Level=informational, Channel=debug
        /// </summary>
        internal static bool WorkflowInstanceAbortedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(44)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowInstance Id: '{0}' was aborted with an exception.
        /// Event description ID=1004, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: WorkflowInstance Id: '{0}' was aborted with an exception.</param>
        /// <param name="exception">Exception associated with the event</param>
        internal static void WorkflowInstanceAborted(string param0, System.Exception exception)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            if (TD.IsEtwEventEnabled(44))
            {
                TD.WriteEtwEvent(44, null, param0, payload.SerializedException, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowInstanceAborted", Culture), param0);
                TD.WriteTraceSource(44, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1003, Level=informational, Channel=debug
        /// </summary>
        internal static bool WorkflowInstanceCanceledIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(45)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowInstance Id: '{0}' has completed in the Canceled state.
        /// Event description ID=1003, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: WorkflowInstance Id: '{0}' has completed in the Canceled state.</param>
        internal static void WorkflowInstanceCanceled(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(45))
            {
                TD.WriteEtwEvent(45, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowInstanceCanceled", Culture), param0);
                TD.WriteTraceSource(45, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1001, Level=informational, Channel=debug
        /// </summary>
        internal static bool WorkflowApplicationCompletedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(46)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowInstance Id: '{0}' has completed in the Closed state.
        /// Event description ID=1001, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: WorkflowInstance Id: '{0}' has completed in the Closed state.</param>
        internal static void WorkflowApplicationCompleted(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(46))
            {
                TD.WriteEtwEvent(46, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationCompleted", Culture), param0);
                TD.WriteTraceSource(46, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1005, Level=informational, Channel=debug
        /// </summary>
        internal static bool WorkflowApplicationIdledIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(47)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowApplication Id: '{0}' went idle.
        /// Event description ID=1005, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: WorkflowApplication Id: '{0}' went idle.</param>
        internal static void WorkflowApplicationIdled(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(47))
            {
                TD.WriteEtwEvent(47, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationIdled", Culture), param0);
                TD.WriteTraceSource(47, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1041, Level=informational, Channel=debug
        /// </summary>
        internal static bool WorkflowApplicationPersistableIdleIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(48)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowApplication Id: '{0}' is idle and persistable.  The following action will be taken: {1}.
        /// Event description ID=1041, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: WorkflowApplication Id: '{0}' is idle and persistable.  The following action will be taken: {1}.</param>
        /// <param name="param1">Parameter 1 for event: WorkflowApplication Id: '{0}' is idle and persistable.  The following action will be taken: {1}.</param>
        internal static void WorkflowApplicationPersistableIdle(string param0, string param1)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(48))
            {
                TD.WriteEtwEvent(48, null, param0, param1, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationPersistableIdle", Culture), param0, param1);
                TD.WriteTraceSource(48, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1007, Level=informational, Channel=debug
        /// </summary>
        internal static bool WorkflowApplicationPersistedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(49)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowApplication Id: '{0}' was Persisted.
        /// Event description ID=1007, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: WorkflowApplication Id: '{0}' was Persisted.</param>
        internal static void WorkflowApplicationPersisted(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(49))
            {
                TD.WriteEtwEvent(49, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationPersisted", Culture), param0);
                TD.WriteTraceSource(49, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1002, Level=informational, Channel=debug
        /// </summary>
        internal static bool WorkflowApplicationTerminatedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(50)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowApplication Id: '{0}' was terminated. It has completed in the Faulted state with an exception.
        /// Event description ID=1002, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: WorkflowApplication Id: '{0}' was terminated. It has completed in the Faulted state with an exception.</param>
        /// <param name="exception">Exception associated with the event</param>
        internal static void WorkflowApplicationTerminated(string param0, System.Exception exception)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            if (TD.IsEtwEventEnabled(50))
            {
                TD.WriteEtwEvent(50, null, param0, payload.SerializedException, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationTerminated", Culture), param0);
                TD.WriteTraceSource(50, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1006, Level=error, Channel=debug
        /// </summary>
        internal static bool WorkflowApplicationUnhandledExceptionIsEnabled()
        {
            return (FxTrace.ShouldTraceError 
                        && (FxTrace.ShouldTraceErrorToTraceSource || TD.IsEtwEventEnabled(51)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowInstance Id: '{0}' has encountered an unhandled exception.  The exception originated from Activity '{1}', DisplayName: '{2}'.  The following action will be taken: {3}.
        /// Event description ID=1006, Level=error, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: WorkflowInstance Id: '{0}' has encountered an unhandled exception.  The exception originated from Activity '{1}', DisplayName: '{2}'.  The following action will be taken: {3}.</param>
        /// <param name="param1">Parameter 1 for event: WorkflowInstance Id: '{0}' has encountered an unhandled exception.  The exception originated from Activity '{1}', DisplayName: '{2}'.  The following action will be taken: {3}.</param>
        /// <param name="param2">Parameter 2 for event: WorkflowInstance Id: '{0}' has encountered an unhandled exception.  The exception originated from Activity '{1}', DisplayName: '{2}'.  The following action will be taken: {3}.</param>
        /// <param name="param3">Parameter 3 for event: WorkflowInstance Id: '{0}' has encountered an unhandled exception.  The exception originated from Activity '{1}', DisplayName: '{2}'.  The following action will be taken: {3}.</param>
        /// <param name="exception">Exception associated with the event</param>
        internal static void WorkflowApplicationUnhandledException(string param0, string param1, string param2, string param3, System.Exception exception)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, exception);
            if (TD.IsEtwEventEnabled(51))
            {
                TD.WriteEtwEvent(51, null, param0, param1, param2, param3, payload.SerializedException, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceErrorToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationUnhandledException", Culture), param0, param1, param2, param3);
                TD.WriteTraceSource(51, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1008, Level=informational, Channel=debug
        /// </summary>
        internal static bool WorkflowApplicationUnloadedIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(52)));
        }
        
        /// <summary>
        /// Gets trace definition like: WorkflowInstance Id: '{0}' was Unloaded.
        /// Event description ID=1008, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: WorkflowInstance Id: '{0}' was Unloaded.</param>
        internal static void WorkflowApplicationUnloaded(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(52))
            {
                TD.WriteEtwEvent(52, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("WorkflowApplicationUnloaded", Culture), param0);
                TD.WriteTraceSource(52, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1124, Level=Informational, Channel=debug
        /// </summary>
        internal static bool InvokeMethodIsStaticIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(53)));
        }
        
        /// <summary>
        /// Gets trace definition like: InvokeMethod '{0}' - method is Static.
        /// Event description ID=1124, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: InvokeMethod '{0}' - method is Static.</param>
        internal static void InvokeMethodIsStatic(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(53))
            {
                TD.WriteEtwEvent(53, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("InvokeMethodIsStatic", Culture), param0);
                TD.WriteTraceSource(53, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1125, Level=Informational, Channel=debug
        /// </summary>
        internal static bool InvokeMethodIsNotStaticIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(54)));
        }
        
        /// <summary>
        /// Gets trace definition like: InvokeMethod '{0}' - method is not Static.
        /// Event description ID=1125, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: InvokeMethod '{0}' - method is not Static.</param>
        internal static void InvokeMethodIsNotStatic(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(54))
            {
                TD.WriteEtwEvent(54, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("InvokeMethodIsNotStatic", Culture), param0);
                TD.WriteTraceSource(54, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1126, Level=Informational, Channel=debug
        /// </summary>
        internal static bool InvokedMethodThrewExceptionIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(55)));
        }
        
        /// <summary>
        /// Gets trace definition like: An exception was thrown in the method called by the activity '{0}'. {1}
        /// Event description ID=1126, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: An exception was thrown in the method called by the activity '{0}'. {1}</param>
        /// <param name="param1">Parameter 1 for event: An exception was thrown in the method called by the activity '{0}'. {1}</param>
        internal static void InvokedMethodThrewException(string param0, string param1)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(55))
            {
                TD.WriteEtwEvent(55, null, param0, param1, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("InvokedMethodThrewException", Culture), param0, param1);
                TD.WriteTraceSource(55, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1131, Level=Informational, Channel=debug
        /// </summary>
        internal static bool InvokeMethodUseAsyncPatternIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(56)));
        }
        
        /// <summary>
        /// Gets trace definition like: InvokeMethod '{0}' - method uses asynchronous pattern of '{1}' and '{2}'.
        /// Event description ID=1131, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: InvokeMethod '{0}' - method uses asynchronous pattern of '{1}' and '{2}'.</param>
        /// <param name="param1">Parameter 1 for event: InvokeMethod '{0}' - method uses asynchronous pattern of '{1}' and '{2}'.</param>
        /// <param name="param2">Parameter 2 for event: InvokeMethod '{0}' - method uses asynchronous pattern of '{1}' and '{2}'.</param>
        internal static void InvokeMethodUseAsyncPattern(string param0, string param1, string param2)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(56))
            {
                TD.WriteEtwEvent(56, null, param0, param1, param2, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("InvokeMethodUseAsyncPattern", Culture), param0, param1, param2);
                TD.WriteTraceSource(56, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1132, Level=Informational, Channel=debug
        /// </summary>
        internal static bool InvokeMethodDoesNotUseAsyncPatternIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(57)));
        }
        
        /// <summary>
        /// Gets trace definition like: InvokeMethod '{0}' - method does not use asynchronous pattern.
        /// Event description ID=1132, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: InvokeMethod '{0}' - method does not use asynchronous pattern.</param>
        internal static void InvokeMethodDoesNotUseAsyncPattern(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(57))
            {
                TD.WriteEtwEvent(57, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("InvokeMethodDoesNotUseAsyncPattern", Culture), param0);
                TD.WriteTraceSource(57, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1140, Level=Informational, Channel=debug
        /// </summary>
        internal static bool FlowchartStartIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(58)));
        }
        
        /// <summary>
        /// Gets trace definition like: Flowchart '{0}' - Start has been scheduled.
        /// Event description ID=1140, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Flowchart '{0}' - Start has been scheduled.</param>
        internal static void FlowchartStart(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(58))
            {
                TD.WriteEtwEvent(58, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("FlowchartStart", Culture), param0);
                TD.WriteTraceSource(58, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1141, Level=Warning, Channel=debug
        /// </summary>
        internal static bool FlowchartEmptyIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning 
                        && (FxTrace.ShouldTraceWarningToTraceSource || TD.IsEtwEventEnabled(59)));
        }
        
        /// <summary>
        /// Gets trace definition like: Flowchart '{0}' - was executed with no Nodes.
        /// Event description ID=1141, Level=Warning, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Flowchart '{0}' - was executed with no Nodes.</param>
        internal static void FlowchartEmpty(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(59))
            {
                TD.WriteEtwEvent(59, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceWarningToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("FlowchartEmpty", Culture), param0);
                TD.WriteTraceSource(59, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1143, Level=Informational, Channel=debug
        /// </summary>
        internal static bool FlowchartNextNullIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(60)));
        }
        
        /// <summary>
        /// Gets trace definition like: Flowchart '{0}'/FlowStep - Next node is null. Flowchart execution will end.
        /// Event description ID=1143, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Flowchart '{0}'/FlowStep - Next node is null. Flowchart execution will end.</param>
        internal static void FlowchartNextNull(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(60))
            {
                TD.WriteEtwEvent(60, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("FlowchartNextNull", Culture), param0);
                TD.WriteTraceSource(60, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1146, Level=Informational, Channel=debug
        /// </summary>
        internal static bool FlowchartSwitchCaseIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(61)));
        }
        
        /// <summary>
        /// Gets trace definition like: Flowchart '{0}'/FlowSwitch - Case '{1}' was selected.
        /// Event description ID=1146, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Flowchart '{0}'/FlowSwitch - Case '{1}' was selected.</param>
        /// <param name="param1">Parameter 1 for event: Flowchart '{0}'/FlowSwitch - Case '{1}' was selected.</param>
        internal static void FlowchartSwitchCase(string param0, string param1)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(61))
            {
                TD.WriteEtwEvent(61, null, param0, param1, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("FlowchartSwitchCase", Culture), param0, param1);
                TD.WriteTraceSource(61, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1147, Level=Informational, Channel=debug
        /// </summary>
        internal static bool FlowchartSwitchDefaultIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(62)));
        }
        
        /// <summary>
        /// Gets trace definition like: Flowchart '{0}'/FlowSwitch - Default Case was selected.
        /// Event description ID=1147, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Flowchart '{0}'/FlowSwitch - Default Case was selected.</param>
        internal static void FlowchartSwitchDefault(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(62))
            {
                TD.WriteEtwEvent(62, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("FlowchartSwitchDefault", Culture), param0);
                TD.WriteTraceSource(62, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1148, Level=Informational, Channel=debug
        /// </summary>
        internal static bool FlowchartSwitchCaseNotFoundIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(63)));
        }
        
        /// <summary>
        /// Gets trace definition like: Flowchart '{0}'/FlowSwitch - could find neither a Case activity nor a Default Case matching the Expression result. Flowchart execution will end.
        /// Event description ID=1148, Level=Informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: Flowchart '{0}'/FlowSwitch - could find neither a Case activity nor a Default Case matching the Expression result. Flowchart execution will end.</param>
        internal static void FlowchartSwitchCaseNotFound(string param0)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(63))
            {
                TD.WriteEtwEvent(63, null, param0, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("FlowchartSwitchCaseNotFound", Culture), param0);
                TD.WriteTraceSource(63, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=1150, Level=informational, Channel=debug
        /// </summary>
        internal static bool CompensationStateIsEnabled()
        {
            return (FxTrace.ShouldTraceInformation 
                        && (FxTrace.ShouldTraceInformationToTraceSource || TD.IsEtwEventEnabled(64)));
        }
        
        /// <summary>
        /// Gets trace definition like: CompensableActivity '{0}' is in the '{1}' state.
        /// Event description ID=1150, Level=informational, Channel=debug
        /// </summary>
        /// <param name="param0">Parameter 0 for event: CompensableActivity '{0}' is in the '{1}' state.</param>
        /// <param name="param1">Parameter 1 for event: CompensableActivity '{0}' is in the '{1}' state.</param>
        internal static void CompensationState(string param0, string param1)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(64))
            {
                TD.WriteEtwEvent(64, null, param0, param1, payload.AppDomainFriendlyName);
            }
            if (FxTrace.ShouldTraceInformationToTraceSource)
            {
                string description = string.Format(Culture, ResourceManager.GetString("CompensationState", Culture), param0, param1);
                TD.WriteTraceSource(64, description, payload);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=39460, Level=Warning, Channel=debug
        /// </summary>
        internal static bool TrackingValueNotSerializableIsEnabled()
        {
            return (FxTrace.ShouldTraceWarning && TD.IsEtwEventEnabled(65));
        }
        
        /// <summary>
        /// Gets trace definition like: The extracted argument/variable '{0}' is not serializable.
        /// Event description ID=39460, Level=Warning, Channel=debug
        /// </summary>
        /// <param name="name">Parameter 0 for event: The extracted argument/variable '{0}' is not serializable.</param>
        internal static void TrackingValueNotSerializable(string name)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(65))
            {
                TD.WriteEtwEvent(65, null, name, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=2021, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool ExecuteWorkItemStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(66));
        }
        
        /// <summary>
        /// Gets trace definition like: Execute work item start
        /// Event description ID=2021, Level=Verbose, Channel=debug
        /// </summary>
        internal static void ExecuteWorkItemStart()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(66))
            {
                TD.WriteEtwEvent(66, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=2022, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool ExecuteWorkItemStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(67));
        }
        
        /// <summary>
        /// Gets trace definition like: Execute work item stop
        /// Event description ID=2022, Level=Verbose, Channel=debug
        /// </summary>
        internal static void ExecuteWorkItemStop()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(67))
            {
                TD.WriteEtwEvent(67, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=2024, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool InternalCacheMetadataStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(68));
        }
        
        /// <summary>
        /// Gets trace definition like: InternalCacheMetadata started on activity '{0}'.
        /// Event description ID=2024, Level=Verbose, Channel=debug
        /// </summary>
        /// <param name="id">Parameter 0 for event: InternalCacheMetadata started on activity '{0}'.</param>
        internal static void InternalCacheMetadataStart(string id)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(68))
            {
                TD.WriteEtwEvent(68, null, id, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=2025, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool InternalCacheMetadataStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(69));
        }
        
        /// <summary>
        /// Gets trace definition like: InternalCacheMetadata stopped on activity '{0}'.
        /// Event description ID=2025, Level=Verbose, Channel=debug
        /// </summary>
        /// <param name="id">Parameter 0 for event: InternalCacheMetadata stopped on activity '{0}'.</param>
        internal static void InternalCacheMetadataStop(string id)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(69))
            {
                TD.WriteEtwEvent(69, null, id, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=2026, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool CompileVbExpressionStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(70));
        }
        
        /// <summary>
        /// Gets trace definition like: Compiling VB expression '{0}'
        /// Event description ID=2026, Level=Verbose, Channel=debug
        /// </summary>
        /// <param name="expr">Parameter 0 for event: Compiling VB expression '{0}'</param>
        internal static void CompileVbExpressionStart(string expr)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(70))
            {
                TD.WriteEtwEvent(70, null, expr, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=2029, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool CompileVbExpressionStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(71));
        }
        
        /// <summary>
        /// Gets trace definition like: Finished compiling VB expression.
        /// Event description ID=2029, Level=Verbose, Channel=debug
        /// </summary>
        internal static void CompileVbExpressionStop()
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(71))
            {
                TD.WriteEtwEvent(71, null, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=2027, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool CacheRootMetadataStartIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(72));
        }
        
        /// <summary>
        /// Gets trace definition like: CacheRootMetadata started on activity '{0}'
        /// Event description ID=2027, Level=Verbose, Channel=debug
        /// </summary>
        /// <param name="activityName">Parameter 0 for event: CacheRootMetadata started on activity '{0}'</param>
        internal static void CacheRootMetadataStart(string activityName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(72))
            {
                TD.WriteEtwEvent(72, null, activityName, payload.AppDomainFriendlyName);
            }
        }
        
        /// <summary>
        /// Check if trace definition is enabled
        /// Event description ID=2028, Level=Verbose, Channel=debug
        /// </summary>
        internal static bool CacheRootMetadataStopIsEnabled()
        {
            return (FxTrace.ShouldTraceVerbose && TD.IsEtwEventEnabled(73));
        }
        
        /// <summary>
        /// Gets trace definition like: CacheRootMetadata stopped on activity {0}.
        /// Event description ID=2028, Level=Verbose, Channel=debug
        /// </summary>
        /// <param name="activityName">Parameter 0 for event: CacheRootMetadata stopped on activity {0}.</param>
        internal static void CacheRootMetadataStop(string activityName)
        {
            TracePayload payload = FxTrace.Trace.GetSerializedPayload(null, null, null);
            if (TD.IsEtwEventEnabled(73))
            {
                TD.WriteEtwEvent(73, null, activityName, 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(39456, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)125, 0xa26, 0x1000000000000040),
                    new System.Runtime.Diagnostics.EventDescriptor(39457, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)126, 0xa26, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(39458, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)127, 0xa26, 0x1000000000000040),
                    new System.Runtime.Diagnostics.EventDescriptor(39459, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0xa25, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1223, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x9e7, 0x1000000002000000),
                    new System.Runtime.Diagnostics.EventDescriptor(2576, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)131, 0xa29, 0x1000000002000000),
                    new System.Runtime.Diagnostics.EventDescriptor(2577, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)129, 0xa29, 0x1000000002000000),
                    new System.Runtime.Diagnostics.EventDescriptor(2578, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)130, 0xa29, 0x1000000002000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1023, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)21, 0x9d6, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1019, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)22, 0x9d6, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1016, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)23, 0x9d6, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1013, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)24, 0x9d6, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1031, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)25, 0x9d6, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1034, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)26, 0x9d6, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1028, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)27, 0x9d6, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1020, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9dc, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1024, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9dc, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1038, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9ff, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1039, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9ff, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1040, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9e7, 0x1000000002000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1037, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)104, 0xa08, 0x1000000004000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1036, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)105, 0xa08, 0x1000000004000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1035, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)106, 0xa08, 0x1000000004000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1021, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)107, 0xa0a, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1017, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)108, 0xa0a, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1014, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)109, 0xa0a, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1011, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)110, 0xa0a, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1029, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)111, 0xa0a, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1032, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)112, 0xa0a, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1026, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)113, 0xa0a, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1022, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)117, 0xa1e, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1018, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)118, 0xa1e, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1015, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)119, 0xa1e, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1012, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)120, 0xa1e, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1030, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)121, 0xa1e, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1033, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)122, 0xa1e, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1027, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)123, 0xa1e, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1025, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Info, 0x9f5, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1104, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Resume, 0xa2f, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1101, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Start, 0xa2f, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1102, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Stop, 0xa2f, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1103, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Suspend, 0xa2f, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1010, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x9d5, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1009, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0xa09, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1004, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)136, 0xa2d, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1003, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)137, 0xa2d, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1001, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)134, 0xa2d, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1005, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)135, 0xa2d, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1041, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)138, 0xa2d, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1007, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)139, 0xa2d, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1002, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)140, 0xa2d, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1006, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Error, (byte)141, 0xa2d, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1008, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)142, 0xa2d, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1124, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)73, 0x9f7, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1125, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)72, 0x9f7, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1126, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)74, 0x9f7, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1131, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)75, 0x9f7, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1132, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)71, 0x9f7, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1140, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)11, 0x9e8, 0x1000000002000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1141, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)60, 0x9e8, 0x1000000002000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1143, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)61, 0x9e8, 0x1000000002000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1146, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)62, 0x9e8, 0x1000000002000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1147, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)64, 0x9e8, 0x1000000002000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1148, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)63, 0x9e8, 0x1000000002000000),
                    new System.Runtime.Diagnostics.EventDescriptor(1150, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Informational, (byte)TraceEventOpcode.Info, 0x9d4, 0x1000000002000000),
                    new System.Runtime.Diagnostics.EventDescriptor(39460, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Warning, (byte)TraceEventOpcode.Info, 0xa25, 0x1000000000000040),
                    new System.Runtime.Diagnostics.EventDescriptor(2021, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9e9, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(2022, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9e9, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(2024, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9f6, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(2025, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9f6, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(2026, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0xa2a, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(2029, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0xa2a, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(2027, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Start, 0x9ce, 0x1000000001000000),
                    new System.Runtime.Diagnostics.EventDescriptor(2028, 0, (byte)TraceChannel.Debug, (byte)TraceEventLevel.Verbose, (byte)TraceEventOpcode.Stop, 0x9ce, 0x1000000001000000)};
            ushort[] e2eEvents = new ushort[0];
            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>>
        /// <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, long 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>>
        // 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>>
        // 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>>
        /// <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 WriteEtwEvent(int eventIndex, System.Runtime.Diagnostics.EventTraceActivity eventParam0, string eventParam1, string eventParam2, string eventParam3, string eventParam4, string eventParam5, string eventParam6)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(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 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>>
        /// <param name="eventParam6">A parameter of the ETW event</param>>
        /// <param name="eventParam7">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, string eventParam6, string eventParam7)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4, eventParam5, eventParam6, eventParam7);
        }
        
        /// <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>>
        /// <param name="eventParam7">A parameter of the ETW event</param>>
        /// <param name="eventParam8">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, string eventParam6, string eventParam7, string eventParam8)
        {
            EnsureEventDescriptors();
            return FxTrace.Trace.EtwProvider.WriteEvent(ref eventDescriptors[eventIndex], eventParam0, eventParam1, eventParam2, eventParam3, eventParam4, eventParam5, eventParam6, eventParam7, eventParam8);
        }
        
        /// <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>>
        // 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)
        {
            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>>
        /// <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>
        /// 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);
        }
    }
}