TraceInternal.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ Dotnetfx_Vista_SP2 / Dotnetfx_Vista_SP2 / 8.0.50727.4016 / DEVDIV / depot / DevDiv / releases / whidbey / NetFxQFE / ndp / fx / src / CompMod / System / Diagnostics / TraceInternal.cs / 1 / TraceInternal.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Diagnostics { 
    using System.Threading; 
    using System.IO;
    using System.Security.Permissions; 
    using System.Collections;

    internal static class TraceInternal {
        private static TraceEventCache eventCache = null; 
        private static string appName = null;
        static TraceListenerCollection listeners; 
        static bool autoFlush; 
        static bool useGlobalLock;
        [ThreadStatic] 
        static int indentLevel;
        static int indentSize;
        static bool settingsInitialized;
        static bool defaultInitialized; 

 
        // this is internal so TraceSource can use it.  We want to lock on the same object because both TraceInternal and 
        // TraceSource could be writing to the same listeners at the same time.
        internal static readonly object critSec = new object(); 

        public static TraceListenerCollection Listeners {
            get {
                InitializeSettings(); 
                if (listeners == null) {
                    lock (critSec) { 
                        if (listeners == null) { 
                            // We only need to check that the main section exists.  Everything else will get
                            // created for us if it doesn't exist already. 
                            SystemDiagnosticsSection configSectionSav = DiagnosticsConfiguration.SystemDiagnosticsSection;
                            if (configSectionSav != null) {
                                listeners = configSectionSav.Trace.Listeners.GetRuntimeObject();
                            } 
                            else {
                                // If machine.config was deleted the code will get to here 
                                // supply at least something to prevent the world from coming to 
                                // an abrupt end.
                                listeners = new TraceListenerCollection(); 
                                TraceListener defaultListener = new DefaultTraceListener();
                                defaultListener.IndentLevel = indentLevel;
                                defaultListener.IndentSize = indentSize;
                                listeners.Add(defaultListener); 
                            }
                        } 
                    } 
                }
                return listeners; 
            }
        }

        internal static string AppName { 
            get {
                if (appName == null) { 
                    new EnvironmentPermission(EnvironmentPermissionAccess.Read, "Path").Assert(); 
                    appName = Path.GetFileName(Environment.GetCommandLineArgs()[0]);
                } 
                return appName;
            }
        }
 
        public static bool AutoFlush {
            get { 
                InitializeSettings(); 
                return autoFlush;
            } 

            set {
                InitializeSettings();
                autoFlush = value; 
            }
        } 
 
        public static bool UseGlobalLock {
            get { 
                InitializeSettings();
                return useGlobalLock;
            }
 
            set {
                InitializeSettings(); 
                useGlobalLock = value; 
            }
        } 

        internal static TraceEventCache EventCache {
            get {
                if (eventCache == null) 
                    eventCache= new TraceEventCache();
 
                return eventCache; 
            }
        } 

        public static int IndentLevel {
            get { return indentLevel; }
 
            set {
                // Use global lock 
                lock (critSec) { 
                    // We don't want to throw here -- it is very bad form to have debug or trace
                    // code throw exceptions! 
                    if (value < 0) {
                        value = 0;
                    }
                    indentLevel = value; 

                    if (listeners != null) { 
                        foreach (TraceListener listener in Listeners) { 
                            listener.IndentLevel = indentLevel;
                        } 
                    }
                }
            }
        } 

        public static int IndentSize { 
            get { 
                InitializeSettings();
                return indentSize; 
            }

            set {
                InitializeSettings(); 
                SetIndentSize(value);
            } 
        } 

        static void SetIndentSize(int value) { 
            // Use global lock
            lock (critSec) {
                // We don't want to throw here -- it is very bad form to have debug or trace
                // code throw exceptions! 
                if (value < 0) {
                    value = 0; 
                } 

                indentSize = value; 

                if (listeners != null) {
                    foreach (TraceListener listener in Listeners) {
                        listener.IndentSize = indentSize; 
                    }
                } 
            } 
        }
 
        public static void Indent() {
            // Use global lock
            lock (critSec) {
                InitializeSettings(); 
                if (indentLevel < Int32.MaxValue) {
                    indentLevel++; 
                } 
                foreach (TraceListener listener in Listeners) {
                    listener.IndentLevel = indentLevel; 
                }
            }
        }
 
        public static void Unindent() {
            // Use global lock 
            lock (critSec) { 
                InitializeSettings();
                if (indentLevel > 0) { 
                    indentLevel--;
                }
                foreach (TraceListener listener in Listeners) {
                    listener.IndentLevel = indentLevel; 
                }
            } 
        } 

        public static void Flush() { 
            if (listeners != null) {
                if (UseGlobalLock) {
                    lock (critSec) {
                        foreach (TraceListener listener in Listeners) { 
                            listener.Flush();
                        } 
                    } 
                }
                else { 
                    foreach (TraceListener listener in Listeners) {
                        if (!listener.IsThreadSafe) {
                            lock (listener) {
                                listener.Flush(); 
                            }
                        } 
                        else { 
                            listener.Flush();
                        } 
                    }
                }
            }
        } 

        public static void Close() { 
            if (listeners != null) { 
                // Use global lock
                lock (critSec) { 
                    foreach (TraceListener listener in Listeners) {
                        listener.Close();
                    }
                } 
            }
        } 
 
        public static void Assert(bool condition) {
            if (condition) return; 
            Fail(string.Empty);
        }

        public static void Assert(bool condition, string message) { 
            if (condition) return;
            Fail(message); 
        } 

        public static void Assert(bool condition, string message, string detailMessage) { 
            if (condition) return;
            Fail(message, detailMessage);
        }
 
        public static void Fail(string message) {
            if (UseGlobalLock) { 
                lock (critSec) { 
                    foreach (TraceListener listener in Listeners) {
                        listener.Fail(message); 
                        if (AutoFlush) listener.Flush();
                    }
                }
            } 
            else {
                foreach (TraceListener listener in Listeners) { 
                    if (!listener.IsThreadSafe) { 
                        lock (listener) {
                            listener.Fail(message); 
                            if (AutoFlush) listener.Flush();
                        }
                    }
                    else { 
                        listener.Fail(message);
                        if (AutoFlush) listener.Flush(); 
                    } 
                }
            } 
        }

        public static void Fail(string message, string detailMessage) {
            if (UseGlobalLock) { 
                lock (critSec) {
                    foreach (TraceListener listener in Listeners) { 
                        listener.Fail(message, detailMessage); 
                        if (AutoFlush) listener.Flush();
                    } 
                }
            }
            else {
                foreach (TraceListener listener in Listeners) { 
                    if (!listener.IsThreadSafe) {
                        lock (listener) { 
                            listener.Fail(message, detailMessage); 
                            if (AutoFlush) listener.Flush();
                        } 
                    }
                    else {
                        listener.Fail(message, detailMessage);
                        if (AutoFlush) listener.Flush(); 
                    }
                } 
            } 
        }
 
        private static void InitializeSettings() {
            // we want to redo this logic exactly once if the last time we entered the config
            // system was still initializing.  (ASURT 111941, VSWhidbey 149552)
            if (!settingsInitialized || (defaultInitialized && DiagnosticsConfiguration.IsInitialized())) { 
                defaultInitialized = DiagnosticsConfiguration.IsInitializing();
 
                // Getting IndentSize and AutoFlush will load config on demand. 
                // If we load config and there are trace listeners added, we'll
                // end up recursing, but that recursion will be stopped in 
                // DiagnosticsConfiguration.Initialize()
                SetIndentSize(DiagnosticsConfiguration.IndentSize);
                autoFlush = DiagnosticsConfiguration.AutoFlush;
                useGlobalLock = DiagnosticsConfiguration.UseGlobalLock; 
                settingsInitialized = true;
            } 
        } 

    	public static void TraceEvent(TraceEventType eventType, int id, string format, params object[] args) { 
            if (UseGlobalLock) {
                lock (critSec) {
                    if (args == null) {
                        foreach (TraceListener listener in Listeners) { 
                            listener.TraceEvent(EventCache, AppName, eventType, id, format);
                            if (AutoFlush) listener.Flush(); 
                        } 
                    }
                    else { 
                        foreach (TraceListener listener in Listeners) {
                            listener.TraceEvent(EventCache, AppName, eventType, id, format, args);
                            if (AutoFlush) listener.Flush();
                        } 
                    }
                } 
            } 
            else {
                if (args == null) { 
                    foreach (TraceListener listener in Listeners) {
                        if (!listener.IsThreadSafe) {
                            lock (listener) {
                                listener.TraceEvent(EventCache, AppName, eventType, id, format); 
                                if (AutoFlush) listener.Flush();
                            } 
                        } 
                        else {
                            listener.TraceEvent(EventCache, AppName, eventType, id, format); 
                            if (AutoFlush) listener.Flush();
                        }
                    }
                } 
                else {
                    foreach (TraceListener listener in Listeners) { 
                        if (!listener.IsThreadSafe) { 
                            lock (listener) {
                                listener.TraceEvent(EventCache, AppName, eventType, id, format, args); 
                                if (AutoFlush) listener.Flush();
                            }
                        }
                        else { 
                            listener.TraceEvent(EventCache, AppName, eventType, id, format, args);
                            if (AutoFlush) listener.Flush(); 
                        } 
                    }
                } 
            }
            EventCache.Clear();
    	}
    	 

        public static void Write(string message) { 
            if (UseGlobalLock) { 
                lock (critSec) {
                    foreach (TraceListener listener in Listeners) { 
                        listener.Write(message);
                        if (AutoFlush) listener.Flush();
                    }
                } 
            }
            else { 
                foreach (TraceListener listener in Listeners) { 
                    if (!listener.IsThreadSafe) {
                        lock (listener) { 
                            listener.Write(message);
                            if (AutoFlush) listener.Flush();
                        }
                    } 
                    else {
                        listener.Write(message); 
                        if (AutoFlush) listener.Flush(); 
                    }
                } 
            }
        }

        public static void Write(object value) { 
            if (UseGlobalLock) {
                lock (critSec) { 
                    foreach (TraceListener listener in Listeners) { 
                        listener.Write(value);
                        if (AutoFlush) listener.Flush(); 
                    }
                }
            }
            else { 
                foreach (TraceListener listener in Listeners) {
                    if (!listener.IsThreadSafe) { 
                        lock (listener) { 
                            listener.Write(value);
                            if (AutoFlush) listener.Flush(); 
                        }
                    }
                    else {
                        listener.Write(value); 
                        if (AutoFlush) listener.Flush();
                    } 
                } 
            }
        } 

        public static void Write(string message, string category) {
            if (UseGlobalLock) {
                lock (critSec) { 
                    foreach (TraceListener listener in Listeners) {
                        listener.Write(message, category); 
                        if (AutoFlush) listener.Flush(); 
                    }
                } 
            }
            else {
                foreach (TraceListener listener in Listeners) {
                    if (!listener.IsThreadSafe) { 
                        lock (listener) {
                            listener.Write(message, category); 
                            if (AutoFlush) listener.Flush(); 
                        }
                    } 
                    else {
                        listener.Write(message, category);
                        if (AutoFlush) listener.Flush();
                    } 
                }
            } 
        } 

        public static void Write(object value, string category) { 
            if (UseGlobalLock) {
                lock (critSec) {
                    foreach (TraceListener listener in Listeners) {
                        listener.Write(value, category); 
                        if (AutoFlush) listener.Flush();
                    } 
                } 
            }
            else { 
                foreach (TraceListener listener in Listeners) {
                    if (!listener.IsThreadSafe) {
                        lock (listener) {
                            listener.Write(value, category); 
                            if (AutoFlush) listener.Flush();
                        } 
                    } 
                    else {
                        listener.Write(value, category); 
                        if (AutoFlush) listener.Flush();
                    }
                }
            } 
        }
 
        public static void WriteLine(string message) { 
            if (UseGlobalLock) {
                lock (critSec) { 
                    foreach (TraceListener listener in Listeners) {
                        listener.WriteLine(message);
                        if (AutoFlush) listener.Flush();
                    } 
                }
            } 
            else { 
                foreach (TraceListener listener in Listeners) {
                    if (!listener.IsThreadSafe) { 
                        lock (listener) {
                            listener.WriteLine(message);
                            if (AutoFlush) listener.Flush();
                        } 
                    }
                    else { 
                        listener.WriteLine(message); 
                        if (AutoFlush) listener.Flush();
                    } 
                }
            }
        }
 
        public static void WriteLine(object value) {
            if (UseGlobalLock) { 
                lock (critSec) { 
                    foreach (TraceListener listener in Listeners) {
                        listener.WriteLine(value); 
                        if (AutoFlush) listener.Flush();
                    }
                }
            } 
            else {
                foreach (TraceListener listener in Listeners) { 
                    if (!listener.IsThreadSafe) { 
                        lock (listener) {
                            listener.WriteLine(value); 
                            if (AutoFlush) listener.Flush();
                        }
                    }
                    else { 
                        listener.WriteLine(value);
                        if (AutoFlush) listener.Flush(); 
                    } 
                }
            } 
        }

        public static void WriteLine(string message, string category) {
            if (UseGlobalLock) { 
                lock (critSec) {
                    foreach (TraceListener listener in Listeners) { 
                        listener.WriteLine(message, category); 
                        if (AutoFlush) listener.Flush();
                    } 
                }
            }
            else {
                foreach (TraceListener listener in Listeners) { 
                    if (!listener.IsThreadSafe) {
                        lock (listener) { 
                            listener.WriteLine(message, category); 
                            if (AutoFlush) listener.Flush();
                        } 
                    }
                    else {
                        listener.WriteLine(message, category);
                        if (AutoFlush) listener.Flush(); 
                    }
                } 
            } 
        }
 
        public static void WriteLine(object value, string category) {
            if (UseGlobalLock) {
                lock (critSec) {
                    foreach (TraceListener listener in Listeners) { 
                        listener.WriteLine(value, category);
                        if (AutoFlush) listener.Flush(); 
                    } 
                }
            } 
            else {
                foreach (TraceListener listener in Listeners) {
                    if (!listener.IsThreadSafe) {
                        lock (listener) { 
                            listener.WriteLine(value, category);
                            if (AutoFlush) listener.Flush(); 
                        } 
                    }
                    else { 
                        listener.WriteLine(value, category);
                        if (AutoFlush) listener.Flush();
                    }
                } 
            }
        } 
 
        public static void WriteIf(bool condition, string message) {
            if (condition) 
                Write(message);
        }

        public static void WriteIf(bool condition, object value) { 
            if (condition)
                Write(value); 
        } 

        public static void WriteIf(bool condition, string message, string category) { 
            if (condition)
                Write(message, category);
        }
 
        public static void WriteIf(bool condition, object value, string category) {
            if (condition) 
                Write(value, category); 
        }
 
        public static void WriteLineIf(bool condition, string message) {
            if (condition)
                WriteLine(message);
        } 

        public static void WriteLineIf(bool condition, object value) { 
            if (condition) 
                WriteLine(value);
        } 

        public static void WriteLineIf(bool condition, string message, string category) {
            if (condition)
                WriteLine(message, category); 
        }
 
        public static void WriteLineIf(bool condition, object value, string category) { 
            if (condition)
                WriteLine(value, category); 
        }
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Diagnostics { 
    using System.Threading; 
    using System.IO;
    using System.Security.Permissions; 
    using System.Collections;

    internal static class TraceInternal {
        private static TraceEventCache eventCache = null; 
        private static string appName = null;
        static TraceListenerCollection listeners; 
        static bool autoFlush; 
        static bool useGlobalLock;
        [ThreadStatic] 
        static int indentLevel;
        static int indentSize;
        static bool settingsInitialized;
        static bool defaultInitialized; 

 
        // this is internal so TraceSource can use it.  We want to lock on the same object because both TraceInternal and 
        // TraceSource could be writing to the same listeners at the same time.
        internal static readonly object critSec = new object(); 

        public static TraceListenerCollection Listeners {
            get {
                InitializeSettings(); 
                if (listeners == null) {
                    lock (critSec) { 
                        if (listeners == null) { 
                            // We only need to check that the main section exists.  Everything else will get
                            // created for us if it doesn't exist already. 
                            SystemDiagnosticsSection configSectionSav = DiagnosticsConfiguration.SystemDiagnosticsSection;
                            if (configSectionSav != null) {
                                listeners = configSectionSav.Trace.Listeners.GetRuntimeObject();
                            } 
                            else {
                                // If machine.config was deleted the code will get to here 
                                // supply at least something to prevent the world from coming to 
                                // an abrupt end.
                                listeners = new TraceListenerCollection(); 
                                TraceListener defaultListener = new DefaultTraceListener();
                                defaultListener.IndentLevel = indentLevel;
                                defaultListener.IndentSize = indentSize;
                                listeners.Add(defaultListener); 
                            }
                        } 
                    } 
                }
                return listeners; 
            }
        }

        internal static string AppName { 
            get {
                if (appName == null) { 
                    new EnvironmentPermission(EnvironmentPermissionAccess.Read, "Path").Assert(); 
                    appName = Path.GetFileName(Environment.GetCommandLineArgs()[0]);
                } 
                return appName;
            }
        }
 
        public static bool AutoFlush {
            get { 
                InitializeSettings(); 
                return autoFlush;
            } 

            set {
                InitializeSettings();
                autoFlush = value; 
            }
        } 
 
        public static bool UseGlobalLock {
            get { 
                InitializeSettings();
                return useGlobalLock;
            }
 
            set {
                InitializeSettings(); 
                useGlobalLock = value; 
            }
        } 

        internal static TraceEventCache EventCache {
            get {
                if (eventCache == null) 
                    eventCache= new TraceEventCache();
 
                return eventCache; 
            }
        } 

        public static int IndentLevel {
            get { return indentLevel; }
 
            set {
                // Use global lock 
                lock (critSec) { 
                    // We don't want to throw here -- it is very bad form to have debug or trace
                    // code throw exceptions! 
                    if (value < 0) {
                        value = 0;
                    }
                    indentLevel = value; 

                    if (listeners != null) { 
                        foreach (TraceListener listener in Listeners) { 
                            listener.IndentLevel = indentLevel;
                        } 
                    }
                }
            }
        } 

        public static int IndentSize { 
            get { 
                InitializeSettings();
                return indentSize; 
            }

            set {
                InitializeSettings(); 
                SetIndentSize(value);
            } 
        } 

        static void SetIndentSize(int value) { 
            // Use global lock
            lock (critSec) {
                // We don't want to throw here -- it is very bad form to have debug or trace
                // code throw exceptions! 
                if (value < 0) {
                    value = 0; 
                } 

                indentSize = value; 

                if (listeners != null) {
                    foreach (TraceListener listener in Listeners) {
                        listener.IndentSize = indentSize; 
                    }
                } 
            } 
        }
 
        public static void Indent() {
            // Use global lock
            lock (critSec) {
                InitializeSettings(); 
                if (indentLevel < Int32.MaxValue) {
                    indentLevel++; 
                } 
                foreach (TraceListener listener in Listeners) {
                    listener.IndentLevel = indentLevel; 
                }
            }
        }
 
        public static void Unindent() {
            // Use global lock 
            lock (critSec) { 
                InitializeSettings();
                if (indentLevel > 0) { 
                    indentLevel--;
                }
                foreach (TraceListener listener in Listeners) {
                    listener.IndentLevel = indentLevel; 
                }
            } 
        } 

        public static void Flush() { 
            if (listeners != null) {
                if (UseGlobalLock) {
                    lock (critSec) {
                        foreach (TraceListener listener in Listeners) { 
                            listener.Flush();
                        } 
                    } 
                }
                else { 
                    foreach (TraceListener listener in Listeners) {
                        if (!listener.IsThreadSafe) {
                            lock (listener) {
                                listener.Flush(); 
                            }
                        } 
                        else { 
                            listener.Flush();
                        } 
                    }
                }
            }
        } 

        public static void Close() { 
            if (listeners != null) { 
                // Use global lock
                lock (critSec) { 
                    foreach (TraceListener listener in Listeners) {
                        listener.Close();
                    }
                } 
            }
        } 
 
        public static void Assert(bool condition) {
            if (condition) return; 
            Fail(string.Empty);
        }

        public static void Assert(bool condition, string message) { 
            if (condition) return;
            Fail(message); 
        } 

        public static void Assert(bool condition, string message, string detailMessage) { 
            if (condition) return;
            Fail(message, detailMessage);
        }
 
        public static void Fail(string message) {
            if (UseGlobalLock) { 
                lock (critSec) { 
                    foreach (TraceListener listener in Listeners) {
                        listener.Fail(message); 
                        if (AutoFlush) listener.Flush();
                    }
                }
            } 
            else {
                foreach (TraceListener listener in Listeners) { 
                    if (!listener.IsThreadSafe) { 
                        lock (listener) {
                            listener.Fail(message); 
                            if (AutoFlush) listener.Flush();
                        }
                    }
                    else { 
                        listener.Fail(message);
                        if (AutoFlush) listener.Flush(); 
                    } 
                }
            } 
        }

        public static void Fail(string message, string detailMessage) {
            if (UseGlobalLock) { 
                lock (critSec) {
                    foreach (TraceListener listener in Listeners) { 
                        listener.Fail(message, detailMessage); 
                        if (AutoFlush) listener.Flush();
                    } 
                }
            }
            else {
                foreach (TraceListener listener in Listeners) { 
                    if (!listener.IsThreadSafe) {
                        lock (listener) { 
                            listener.Fail(message, detailMessage); 
                            if (AutoFlush) listener.Flush();
                        } 
                    }
                    else {
                        listener.Fail(message, detailMessage);
                        if (AutoFlush) listener.Flush(); 
                    }
                } 
            } 
        }
 
        private static void InitializeSettings() {
            // we want to redo this logic exactly once if the last time we entered the config
            // system was still initializing.  (ASURT 111941, VSWhidbey 149552)
            if (!settingsInitialized || (defaultInitialized && DiagnosticsConfiguration.IsInitialized())) { 
                defaultInitialized = DiagnosticsConfiguration.IsInitializing();
 
                // Getting IndentSize and AutoFlush will load config on demand. 
                // If we load config and there are trace listeners added, we'll
                // end up recursing, but that recursion will be stopped in 
                // DiagnosticsConfiguration.Initialize()
                SetIndentSize(DiagnosticsConfiguration.IndentSize);
                autoFlush = DiagnosticsConfiguration.AutoFlush;
                useGlobalLock = DiagnosticsConfiguration.UseGlobalLock; 
                settingsInitialized = true;
            } 
        } 

    	public static void TraceEvent(TraceEventType eventType, int id, string format, params object[] args) { 
            if (UseGlobalLock) {
                lock (critSec) {
                    if (args == null) {
                        foreach (TraceListener listener in Listeners) { 
                            listener.TraceEvent(EventCache, AppName, eventType, id, format);
                            if (AutoFlush) listener.Flush(); 
                        } 
                    }
                    else { 
                        foreach (TraceListener listener in Listeners) {
                            listener.TraceEvent(EventCache, AppName, eventType, id, format, args);
                            if (AutoFlush) listener.Flush();
                        } 
                    }
                } 
            } 
            else {
                if (args == null) { 
                    foreach (TraceListener listener in Listeners) {
                        if (!listener.IsThreadSafe) {
                            lock (listener) {
                                listener.TraceEvent(EventCache, AppName, eventType, id, format); 
                                if (AutoFlush) listener.Flush();
                            } 
                        } 
                        else {
                            listener.TraceEvent(EventCache, AppName, eventType, id, format); 
                            if (AutoFlush) listener.Flush();
                        }
                    }
                } 
                else {
                    foreach (TraceListener listener in Listeners) { 
                        if (!listener.IsThreadSafe) { 
                            lock (listener) {
                                listener.TraceEvent(EventCache, AppName, eventType, id, format, args); 
                                if (AutoFlush) listener.Flush();
                            }
                        }
                        else { 
                            listener.TraceEvent(EventCache, AppName, eventType, id, format, args);
                            if (AutoFlush) listener.Flush(); 
                        } 
                    }
                } 
            }
            EventCache.Clear();
    	}
    	 

        public static void Write(string message) { 
            if (UseGlobalLock) { 
                lock (critSec) {
                    foreach (TraceListener listener in Listeners) { 
                        listener.Write(message);
                        if (AutoFlush) listener.Flush();
                    }
                } 
            }
            else { 
                foreach (TraceListener listener in Listeners) { 
                    if (!listener.IsThreadSafe) {
                        lock (listener) { 
                            listener.Write(message);
                            if (AutoFlush) listener.Flush();
                        }
                    } 
                    else {
                        listener.Write(message); 
                        if (AutoFlush) listener.Flush(); 
                    }
                } 
            }
        }

        public static void Write(object value) { 
            if (UseGlobalLock) {
                lock (critSec) { 
                    foreach (TraceListener listener in Listeners) { 
                        listener.Write(value);
                        if (AutoFlush) listener.Flush(); 
                    }
                }
            }
            else { 
                foreach (TraceListener listener in Listeners) {
                    if (!listener.IsThreadSafe) { 
                        lock (listener) { 
                            listener.Write(value);
                            if (AutoFlush) listener.Flush(); 
                        }
                    }
                    else {
                        listener.Write(value); 
                        if (AutoFlush) listener.Flush();
                    } 
                } 
            }
        } 

        public static void Write(string message, string category) {
            if (UseGlobalLock) {
                lock (critSec) { 
                    foreach (TraceListener listener in Listeners) {
                        listener.Write(message, category); 
                        if (AutoFlush) listener.Flush(); 
                    }
                } 
            }
            else {
                foreach (TraceListener listener in Listeners) {
                    if (!listener.IsThreadSafe) { 
                        lock (listener) {
                            listener.Write(message, category); 
                            if (AutoFlush) listener.Flush(); 
                        }
                    } 
                    else {
                        listener.Write(message, category);
                        if (AutoFlush) listener.Flush();
                    } 
                }
            } 
        } 

        public static void Write(object value, string category) { 
            if (UseGlobalLock) {
                lock (critSec) {
                    foreach (TraceListener listener in Listeners) {
                        listener.Write(value, category); 
                        if (AutoFlush) listener.Flush();
                    } 
                } 
            }
            else { 
                foreach (TraceListener listener in Listeners) {
                    if (!listener.IsThreadSafe) {
                        lock (listener) {
                            listener.Write(value, category); 
                            if (AutoFlush) listener.Flush();
                        } 
                    } 
                    else {
                        listener.Write(value, category); 
                        if (AutoFlush) listener.Flush();
                    }
                }
            } 
        }
 
        public static void WriteLine(string message) { 
            if (UseGlobalLock) {
                lock (critSec) { 
                    foreach (TraceListener listener in Listeners) {
                        listener.WriteLine(message);
                        if (AutoFlush) listener.Flush();
                    } 
                }
            } 
            else { 
                foreach (TraceListener listener in Listeners) {
                    if (!listener.IsThreadSafe) { 
                        lock (listener) {
                            listener.WriteLine(message);
                            if (AutoFlush) listener.Flush();
                        } 
                    }
                    else { 
                        listener.WriteLine(message); 
                        if (AutoFlush) listener.Flush();
                    } 
                }
            }
        }
 
        public static void WriteLine(object value) {
            if (UseGlobalLock) { 
                lock (critSec) { 
                    foreach (TraceListener listener in Listeners) {
                        listener.WriteLine(value); 
                        if (AutoFlush) listener.Flush();
                    }
                }
            } 
            else {
                foreach (TraceListener listener in Listeners) { 
                    if (!listener.IsThreadSafe) { 
                        lock (listener) {
                            listener.WriteLine(value); 
                            if (AutoFlush) listener.Flush();
                        }
                    }
                    else { 
                        listener.WriteLine(value);
                        if (AutoFlush) listener.Flush(); 
                    } 
                }
            } 
        }

        public static void WriteLine(string message, string category) {
            if (UseGlobalLock) { 
                lock (critSec) {
                    foreach (TraceListener listener in Listeners) { 
                        listener.WriteLine(message, category); 
                        if (AutoFlush) listener.Flush();
                    } 
                }
            }
            else {
                foreach (TraceListener listener in Listeners) { 
                    if (!listener.IsThreadSafe) {
                        lock (listener) { 
                            listener.WriteLine(message, category); 
                            if (AutoFlush) listener.Flush();
                        } 
                    }
                    else {
                        listener.WriteLine(message, category);
                        if (AutoFlush) listener.Flush(); 
                    }
                } 
            } 
        }
 
        public static void WriteLine(object value, string category) {
            if (UseGlobalLock) {
                lock (critSec) {
                    foreach (TraceListener listener in Listeners) { 
                        listener.WriteLine(value, category);
                        if (AutoFlush) listener.Flush(); 
                    } 
                }
            } 
            else {
                foreach (TraceListener listener in Listeners) {
                    if (!listener.IsThreadSafe) {
                        lock (listener) { 
                            listener.WriteLine(value, category);
                            if (AutoFlush) listener.Flush(); 
                        } 
                    }
                    else { 
                        listener.WriteLine(value, category);
                        if (AutoFlush) listener.Flush();
                    }
                } 
            }
        } 
 
        public static void WriteIf(bool condition, string message) {
            if (condition) 
                Write(message);
        }

        public static void WriteIf(bool condition, object value) { 
            if (condition)
                Write(value); 
        } 

        public static void WriteIf(bool condition, string message, string category) { 
            if (condition)
                Write(message, category);
        }
 
        public static void WriteIf(bool condition, object value, string category) {
            if (condition) 
                Write(value, category); 
        }
 
        public static void WriteLineIf(bool condition, string message) {
            if (condition)
                WriteLine(message);
        } 

        public static void WriteLineIf(bool condition, object value) { 
            if (condition) 
                WriteLine(value);
        } 

        public static void WriteLineIf(bool condition, string message, string category) {
            if (condition)
                WriteLine(message, category); 
        }
 
        public static void WriteLineIf(bool condition, object value, string category) { 
            if (condition)
                WriteLine(value, category); 
        }
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK