/Microsoft.Build/Microsoft.Build/Microsoft/Build/Execution/BuildParameters.cs

namespace Microsoft.Build.Execution

{

    using Microsoft.Build.BackEnd;

    using Microsoft.Build.Collections;

    using Microsoft.Build.Evaluation;

    using Microsoft.Build.Framework;

    using Microsoft.Build.Logging;

    using Microsoft.Build.Shared;

    using System;

    using System.Collections.Generic;

    using System.Globalization;

    using System.IO;

    using System.Reflection;

    using System.Runtime;

    using System.Runtime.CompilerServices;

    using System.Threading;



    public class BuildParameters : INodePacketTranslatable

    {

        private int buildId;

        private ThreadPriority buildThreadPriority;

        private CultureInfo culture;

        private const int DefaultEndpointShutdownTimeout = 0x7530;

        private const int DefaultEngineShutdownTimeout = -1;

        private const int DefaultIdleRequestBuilderLimit = 10;

        private const int DefaultLoggingThreadShutdownTimeout = 0x7530;

        private const int DefaultNodeConnectionTimeout = 0xdbba0;

        private const int DefaultRequestBuilderShutdownTimeout = -1;

        private const int DefaultThreadStackSize = 0x40000;

        private string defaultToolsVersion;

        private bool detailedSummary;

        private bool enableNodeReuse;

        private PropertyDictionary<ProjectPropertyInstance> environmentProperties;

        private IEnumerable<ForwardingLoggerRecord> forwardingLoggers;

        private PropertyDictionary<ProjectPropertyInstance> globalProperties;

        private Microsoft.Build.Execution.HostServices hostServices;

        private IEnumerable<ILogger> loggers;

        private int maxNodeCount;

        private int memoryUseLimit;

        private string nodeExeLocation;

        private int nodeId;

        private bool onlyLogCriticalEvents;

        private bool saveOperatingEnvironment;

        private static string startupDirectory = NativeMethodsShared.GetCurrentDirectory();

        private Microsoft.Build.Evaluation.ToolsetDefinitionLocations toolsetDefinitionLocations;

        private Microsoft.Build.Evaluation.ToolsetProvider toolsetProvider;

        private CultureInfo uiCulture;

        private bool useSynchronousLogging;



        public BuildParameters() : this(Utilities.GetEnvironmentProperties(), new Microsoft.Build.Evaluation.ProjectRootElementCache(false))

        {

        }



        private BuildParameters(INodePacketTranslator translator)

        {

            this.buildThreadPriority = ThreadPriority.Normal;

            this.culture = Thread.CurrentThread.CurrentCulture;

            this.defaultToolsVersion = "2.0";

            this.enableNodeReuse = true;

            this.environmentProperties = new PropertyDictionary<ProjectPropertyInstance>();

            this.globalProperties = new PropertyDictionary<ProjectPropertyInstance>();

            this.maxNodeCount = 1;

            this.toolsetDefinitionLocations = Microsoft.Build.Evaluation.ToolsetDefinitionLocations.Registry | Microsoft.Build.Evaluation.ToolsetDefinitionLocations.ConfigurationFile;

            this.uiCulture = Thread.CurrentThread.CurrentUICulture;

            this.saveOperatingEnvironment = true;

            ((INodePacketTranslatable) this).Translate(translator);

        }



        public BuildParameters(ProjectCollection projectCollection) : this(new PropertyDictionary<ProjectPropertyInstance>(projectCollection.EnvironmentProperties), projectCollection.ProjectRootElementCache)

        {

            ErrorUtilities.VerifyThrowArgumentNull(projectCollection, "projectCollection");

            this.maxNodeCount = projectCollection.MaxNodeCount;

            this.onlyLogCriticalEvents = projectCollection.OnlyLogCriticalEvents;

            this.toolsetDefinitionLocations = projectCollection.ToolsetLocations;

            this.defaultToolsVersion = projectCollection.DefaultToolsVersion;

            this.globalProperties = new PropertyDictionary<ProjectPropertyInstance>(projectCollection.GlobalPropertiesCollection);

            this.toolsetProvider = new Microsoft.Build.Evaluation.ToolsetProvider(projectCollection.Toolsets);

        }



        private BuildParameters(BuildParameters other)

        {

            this.buildThreadPriority = ThreadPriority.Normal;

            this.culture = Thread.CurrentThread.CurrentCulture;

            this.defaultToolsVersion = "2.0";

            this.enableNodeReuse = true;

            this.environmentProperties = new PropertyDictionary<ProjectPropertyInstance>();

            this.globalProperties = new PropertyDictionary<ProjectPropertyInstance>();

            this.maxNodeCount = 1;

            this.toolsetDefinitionLocations = Microsoft.Build.Evaluation.ToolsetDefinitionLocations.Registry | Microsoft.Build.Evaluation.ToolsetDefinitionLocations.ConfigurationFile;

            this.uiCulture = Thread.CurrentThread.CurrentUICulture;

            this.saveOperatingEnvironment = true;

            ErrorUtilities.VerifyThrowInternalNull(other, "other");

            this.buildId = other.buildId;

            this.culture = other.culture;

            this.defaultToolsVersion = other.defaultToolsVersion;

            this.enableNodeReuse = other.enableNodeReuse;

            this.environmentProperties = (other.environmentProperties != null) ? new PropertyDictionary<ProjectPropertyInstance>(other.environmentProperties) : null;

            this.forwardingLoggers = (other.forwardingLoggers != null) ? new List<ForwardingLoggerRecord>(other.forwardingLoggers) : null;

            this.globalProperties = (other.globalProperties != null) ? new PropertyDictionary<ProjectPropertyInstance>(other.globalProperties) : null;

            this.hostServices = other.hostServices;

            this.loggers = (other.loggers != null) ? new List<ILogger>(other.loggers) : null;

            this.maxNodeCount = other.maxNodeCount;

            this.memoryUseLimit = other.memoryUseLimit;

            this.nodeExeLocation = other.nodeExeLocation;

            this.nodeId = other.nodeId;

            this.onlyLogCriticalEvents = other.onlyLogCriticalEvents;

            this.buildThreadPriority = other.buildThreadPriority;

            this.toolsetProvider = other.toolsetProvider;

            this.toolsetDefinitionLocations = other.toolsetDefinitionLocations;

            this.toolsetProvider = other.toolsetProvider;

            this.uiCulture = other.uiCulture;

            this.detailedSummary = other.detailedSummary;

            this.ProjectRootElementCache = other.ProjectRootElementCache;

            this.ResetCaches = other.ResetCaches;

            this.LegacyThreadingSemantics = other.LegacyThreadingSemantics;

            this.saveOperatingEnvironment = other.saveOperatingEnvironment;

            this.useSynchronousLogging = other.useSynchronousLogging;

        }



        private BuildParameters(PropertyDictionary<ProjectPropertyInstance> environmentProperties, Microsoft.Build.Evaluation.ProjectRootElementCache projectRootElementCache)

        {

            this.buildThreadPriority = ThreadPriority.Normal;

            this.culture = Thread.CurrentThread.CurrentCulture;

            this.defaultToolsVersion = "2.0";

            this.enableNodeReuse = true;

            this.environmentProperties = new PropertyDictionary<ProjectPropertyInstance>();

            this.globalProperties = new PropertyDictionary<ProjectPropertyInstance>();

            this.maxNodeCount = 1;

            this.toolsetDefinitionLocations = Microsoft.Build.Evaluation.ToolsetDefinitionLocations.Registry | Microsoft.Build.Evaluation.ToolsetDefinitionLocations.ConfigurationFile;

            this.uiCulture = Thread.CurrentThread.CurrentUICulture;

            this.saveOperatingEnvironment = true;

            this.environmentProperties = environmentProperties;

            this.ProjectRootElementCache = projectRootElementCache;

            this.ResetCaches = true;

            if (Environment.GetEnvironmentVariable("MSBUILDDISABLENODEREUSE") == "1")

            {

                this.enableNodeReuse = false;

            }

            if (Environment.GetEnvironmentVariable("MSBUILDDETAILEDSUMMARY") == "1")

            {

                this.detailedSummary = true;

            }

            this.FindMSBuildExe();

        }



        public BuildParameters Clone()

        {

            return new BuildParameters(this);

        }



        private void EnsureToolsets()

        {

            if (this.toolsetProvider == null)

            {

                this.toolsetProvider = new Microsoft.Build.Evaluation.ToolsetProvider(this.DefaultToolsVersion, this.environmentProperties, this.globalProperties, this.ToolsetDefinitionLocations);

            }

        }



        internal static BuildParameters FactoryForDeserialization(INodePacketTranslator translator)

        {

            return new BuildParameters(translator);

        }



        private void FindMSBuildExe()

        {

            if ((this.nodeExeLocation == null) || !File.Exists(this.nodeExeLocation))

            {

                string environmentVariable = Environment.GetEnvironmentVariable("MSBUILD_EXE_PATH");

                if ((environmentVariable != null) && File.Exists(environmentVariable))

                {

                    this.nodeExeLocation = environmentVariable;

                }

                else

                {

                    environmentVariable = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "MSBuild.exe");

                    if ((environmentVariable != null) && File.Exists(environmentVariable))

                    {

                        this.nodeExeLocation = environmentVariable;

                    }

                    else

                    {

                        foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())

                        {

                            if (!assembly.IsDynamic)

                            {

                                try

                                {

                                    environmentVariable = Path.GetDirectoryName(assembly.Location);

                                }

                                catch (Exception)

                                {

                                    goto Label_00AD;

                                }

                                if (File.Exists(Path.Combine(environmentVariable, "MSBuild.exe")))

                                {

                                    this.nodeExeLocation = Path.Combine(environmentVariable, "MSBuild.exe");

                                    return;

                                }

                            Label_00AD:;

                            }

                        }

                        environmentVariable = FrameworkLocationHelper.PathToDotNetFrameworkV40;

                        if ((environmentVariable != null) && File.Exists(Path.Combine(environmentVariable, "MSBuild.exe")))

                        {

                            this.nodeExeLocation = Path.Combine(environmentVariable, "MSBuild.exe");

                        }

                    }

                }

            }

        }



        private static int GetTimeoutVariableOrDefault(string environmentVariable, int defaultValue)

        {

            string str = Environment.GetEnvironmentVariable(environmentVariable);

            if (string.IsNullOrEmpty(str))

            {

                return defaultValue;

            }

            try

            {

                return Convert.ToInt32(str, CultureInfo.InvariantCulture);

            }

            catch (Exception exception)

            {

                if (ExceptionHandling.IsCriticalException(exception))

                {

                    throw;

                }

                return defaultValue;

            }

        }



        public Toolset GetToolset(string toolsVersion)

        {

            this.EnsureToolsets();

            return this.toolsetProvider.GetToolset(toolsVersion);

        }



        void INodePacketTranslatable.Translate(INodePacketTranslator translator)

        {

            translator.Translate(ref this.buildId);

            translator.TranslateCulture(ref this.culture);

            translator.Translate(ref this.defaultToolsVersion);

            translator.Translate(ref this.enableNodeReuse);

            translator.TranslateProjectPropertyInstanceDictionary(ref this.environmentProperties);

            translator.TranslateProjectPropertyInstanceDictionary(ref this.globalProperties);

            translator.Translate(ref this.maxNodeCount);

            translator.Translate(ref this.memoryUseLimit);

            translator.Translate(ref this.nodeExeLocation);

            translator.Translate(ref this.onlyLogCriticalEvents);

            translator.Translate(ref startupDirectory);

            translator.TranslateCulture(ref this.uiCulture);

            translator.Translate<Microsoft.Build.Evaluation.ToolsetProvider>(ref this.toolsetProvider, new NodePacketValueFactory<Microsoft.Build.Evaluation.ToolsetProvider>(Microsoft.Build.Evaluation.ToolsetProvider.FactoryForDeserialization));

            translator.Translate(ref this.useSynchronousLogging);

        }



        internal System.AppDomainSetup AppDomainSetup

        {

            [CompilerGenerated, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.<AppDomainSetup>k__BackingField;

            }

            [CompilerGenerated, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.<AppDomainSetup>k__BackingField = value;

            }

        }



        internal int BuildId

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.buildId;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.buildId = value;

            }

        }



        public ThreadPriority BuildThreadPriority

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.buildThreadPriority;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.buildThreadPriority = value;

            }

        }



        public CultureInfo Culture

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.culture;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.culture = value;

            }

        }



        public string DefaultToolsVersion

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.defaultToolsVersion;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.defaultToolsVersion = value;

            }

        }



        public bool DetailedSummary

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.detailedSummary;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.detailedSummary = value;

            }

        }



        public bool EnableNodeReuse

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.enableNodeReuse;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.enableNodeReuse = value;

            }

        }



        internal static int EndpointShutdownTimeout

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return GetTimeoutVariableOrDefault("MSBUILDENDPOINTSHUTDOWNTIMEOUT", 0x7530);

            }

        }



        internal static int EngineShutdownTimeout

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return GetTimeoutVariableOrDefault("MSBUILDENGINESHUTDOWNTIMEOUT", -1);

            }

        }



        public IDictionary<string, string> EnvironmentProperties

        {

            get

            {

                return new ReadOnlyConvertingDictionary<string, ProjectPropertyInstance, string>(this.environmentProperties, instance => ((IProperty) instance).EvaluatedValueEscaped);

            }

        }



        internal PropertyDictionary<ProjectPropertyInstance> EnvironmentPropertiesInternal

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.environmentProperties;

            }

            set

            {

                ErrorUtilities.VerifyThrowInternalNull(value, "EnvironmentPropertiesInternal");

                this.environmentProperties = value;

            }

        }



        public IEnumerable<ForwardingLoggerRecord> ForwardingLoggers

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.forwardingLoggers;

            }

            set

            {

                if (value != null)

                {

                    foreach (ForwardingLoggerRecord record in value)

                    {

                        ErrorUtilities.VerifyThrowArgumentNull(record, "ForwardingLoggers", "NullLoggerNotAllowed");

                    }

                }

                this.forwardingLoggers = value;

            }

        }



        public IDictionary<string, string> GlobalProperties

        {

            get

            {

                return new ReadOnlyConvertingDictionary<string, ProjectPropertyInstance, string>(this.globalProperties, instance => ((IProperty) instance).EvaluatedValueEscaped);

            }

            set

            {

                this.globalProperties = new PropertyDictionary<ProjectPropertyInstance>(value.Count);

                foreach (KeyValuePair<string, string> pair in value)

                {

                    this.globalProperties[pair.Key] = new ProjectPropertyInstance(pair.Key, pair.Value);

                }

            }

        }



        internal PropertyDictionary<ProjectPropertyInstance> GlobalPropertiesInternal

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.globalProperties;

            }

        }



        public Microsoft.Build.Execution.HostServices HostServices

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.hostServices;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.hostServices = value;

            }

        }



        internal static int IdleRequestBuilderLimit

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return GetTimeoutVariableOrDefault("MSBUILDIDLEREQUESTBUILDERLIMIT", 10);

            }

        }



        internal bool IsOutOfProc

        {

            [CompilerGenerated, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.<IsOutOfProc>k__BackingField;

            }

            [CompilerGenerated, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.<IsOutOfProc>k__BackingField = value;

            }

        }



        public bool LegacyThreadingSemantics

        {

            [CompilerGenerated, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.<LegacyThreadingSemantics>k__BackingField;

            }

            [CompilerGenerated, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.<LegacyThreadingSemantics>k__BackingField = value;

            }

        }



        public IEnumerable<ILogger> Loggers

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.loggers;

            }

            set

            {

                if (value != null)

                {

                    foreach (ILogger logger in value)

                    {

                        ErrorUtilities.VerifyThrowArgumentNull(logger, "Loggers", "NullLoggerNotAllowed");

                    }

                }

                this.loggers = value;

            }

        }



        internal static int LoggingThreadShutdownTimeout

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return GetTimeoutVariableOrDefault("MSBUILDLOGGINGTHREADSHUTDOWNTIMEOUT", 0x7530);

            }

        }



        public int MaxNodeCount

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.maxNodeCount;

            }

            set

            {

                ErrorUtilities.VerifyThrowArgument(value > 0, "InvalidMaxNodeCount");

                this.maxNodeCount = value;

            }

        }



        public int MemoryUseLimit

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.memoryUseLimit;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.memoryUseLimit = value;

            }

        }



        internal int MemoryUseLimitPerNode

        {

            get

            {

                return (this.MemoryUseLimit / this.MaxNodeCount);

            }

        }



        internal static int NodeConnectionTimeout

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return GetTimeoutVariableOrDefault("MSBUILDNODECONNECTIONTIMEOUT", 0xdbba0);

            }

        }



        public string NodeExeLocation

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.nodeExeLocation;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.nodeExeLocation = value;

            }

        }



        internal int NodeId

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.nodeId;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.nodeId = value;

            }

        }



        public bool OnlyLogCriticalEvents

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.onlyLogCriticalEvents;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.onlyLogCriticalEvents = value;

            }

        }



        internal Microsoft.Build.Evaluation.ProjectRootElementCache ProjectRootElementCache

        {

            [CompilerGenerated, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.<ProjectRootElementCache>k__BackingField;

            }

            [CompilerGenerated, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.<ProjectRootElementCache>k__BackingField = value;

            }

        }



        internal static int RequestBuilderShutdownTimeout

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return GetTimeoutVariableOrDefault("MSBUILDREQUESTBUILDERSHUTDOWNTIMEOUT", -1);

            }

        }



        public bool ResetCaches

        {

            [CompilerGenerated, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.<ResetCaches>k__BackingField;

            }

            [CompilerGenerated, TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.<ResetCaches>k__BackingField = value;

            }

        }



        public bool SaveOperatingEnvironment

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.saveOperatingEnvironment;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.saveOperatingEnvironment = value;

            }

        }



        internal static string StartupDirectory

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return startupDirectory;

            }

        }



        internal static int ThreadStackSize

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return GetTimeoutVariableOrDefault("MSBUILDTHREADSTACKSIZE", 0x40000);

            }

        }



        public Microsoft.Build.Evaluation.ToolsetDefinitionLocations ToolsetDefinitionLocations

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.toolsetDefinitionLocations;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.toolsetDefinitionLocations = value;

            }

        }



        internal IToolsetProvider ToolsetProvider

        {

            get

            {

                this.EnsureToolsets();

                return this.toolsetProvider;

            }

        }



        public ICollection<Toolset> Toolsets

        {

            get

            {

                return this.toolsetProvider.Toolsets;

            }

        }



        public CultureInfo UICulture

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.uiCulture;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.uiCulture = value;

            }

        }



        public bool UseSynchronousLogging

        {

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            get

            {

                return this.useSynchronousLogging;

            }

            [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]

            set

            {

                this.useSynchronousLogging = value;

            }

        }

    }

}