BCLDebug.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / clr / src / BCL / System / BCLDebug.cs / 1305376 / BCLDebug.cs
                        
                        
                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 
/*============================================================
** 
** Class: BCLDebug 
**
** 
** Purpose: Debugging Macros for use in the Base Class Libraries
**
**
============================================================*/ 

namespace System { 
 
    using System.IO;
    using System.Text; 
    using System.Runtime.Remoting;
    using System.Diagnostics;
    using Microsoft.Win32;
    using System.Runtime.CompilerServices; 
    using System.Runtime.Versioning;
    using System.Security.Permissions; 
    using System.Security; 
    using System.Diagnostics.Contracts;
 
    [Serializable]
    internal enum LogLevel {
        Trace  = 0,
        Status = 20, 
        Warning= 40,
        Error  = 50, 
        Panic  = 100, 
    }
 
    internal struct SwitchStructure {
        internal String name;
        internal int    value;
 
        internal SwitchStructure (String n, int v) {
            name = n; 
            value = v; 
        }
    } 


    // Only statics, does not need to be marked with the serializable attribute
    [System.Security.SecuritySafeCritical]  // auto-generated 
    internal static class BCLDebug {
        internal static bool m_registryChecked=false; 
        internal static bool m_loggingNotEnabled = false; 
        internal static bool m_perfWarnings;
        internal static bool m_correctnessWarnings; 
        internal static bool m_safeHandleStackTraces;
#if _DEBUG
        internal static bool m_domainUnloadAdded;
#endif 
        internal static PermissionSet m_MakeConsoleErrorLoggingWork;
 
        static readonly SwitchStructure[] switches = { 
            new SwitchStructure("NLS",  0x00000001),
            new SwitchStructure("SER",  0x00000002), 
            new SwitchStructure("DYNIL",0x00000004),
            new SwitchStructure("REMOTE",0x00000008),
            new SwitchStructure("BINARY",0x00000010),   //Binary Formatter
            new SwitchStructure("SOAP",0x00000020),     // Soap Formatter 
            new SwitchStructure("REMOTINGCHANNELS",0x00000040),
            new SwitchStructure("CACHE",0x00000080), 
            new SwitchStructure("RESMGRFILEFORMAT", 0x00000100), // .resources files 
            new SwitchStructure("PERF", 0x00000200),
            new SwitchStructure("CORRECTNESS", 0x00000400), 
            new SwitchStructure("MEMORYFAILPOINT", 0x00000800),
            new SwitchStructure("DATETIME", 0x00001000), // System.DateTime managed tracing
        };
 
        static readonly LogLevel[] levelConversions = {
            LogLevel.Panic, 
            LogLevel.Error, 
            LogLevel.Error,
            LogLevel.Warning, 
            LogLevel.Warning,
            LogLevel.Status,
            LogLevel.Status,
            LogLevel.Trace, 
            LogLevel.Trace,
            LogLevel.Trace, 
            LogLevel.Trace 
        };
 

#if _DEBUG
        internal static void WaitForFinalizers(Object sender, EventArgs e)
        { 
            if (!m_registryChecked) {
                CheckRegistry(); 
            } 
            if (m_correctnessWarnings) {
                GC.GetTotalMemory(true); 
                GC.WaitForPendingFinalizers();
            }
        }
#endif 

        [Conditional("_DEBUG")] 
        [ResourceExposure(ResourceScope.None)] 
        static public void Assert(bool condition, String message) {
#if _DEBUG 
            // Speed up debug builds marginally by avoiding the garbage from
            // concatinating "BCL Assert: " and the message.
            if (!condition)
                System.Diagnostics.Assert.Check(condition, "BCL Assert", message); 
#endif
        } 
 
        [Pure]
        [Conditional("_LOGGING")] 
        [ResourceExposure(ResourceScope.None)]
        static public void Log(String message) {
            if (AppDomain.CurrentDomain.IsUnloadingForcedFinalize())
                return; 
            if (!m_registryChecked) {
                CheckRegistry(); 
            } 
            System.Diagnostics.Log.Trace(message);
            System.Diagnostics.Log.Trace(Environment.NewLine); 
        }

        [Pure]
        [Conditional("_LOGGING")] 
        [ResourceExposure(ResourceScope.None)]
        static public void Log(String switchName, String message) { 
            if (AppDomain.CurrentDomain.IsUnloadingForcedFinalize()) 
                return;
            if (!m_registryChecked) { 
                CheckRegistry();
            }
            try {
                LogSwitch ls; 
                ls = LogSwitch.GetSwitch(switchName);
                if (ls!=null) { 
                    System.Diagnostics.Log.Trace(ls,message); 
                    System.Diagnostics.Log.Trace(ls,Environment.NewLine);
                } 
            } catch {
                System.Diagnostics.Log.Trace("Exception thrown in logging." + Environment.NewLine);
                System.Diagnostics.Log.Trace("Switch was: " + ((switchName==null)?"":switchName) + Environment.NewLine);
                System.Diagnostics.Log.Trace("Message was: " + ((message==null)?"":message) + Environment.NewLine); 
            }
        } 
 
        //
        // This code gets called during security startup, so we can't go through Marshal to get the values.  This is 
        // just a small helper in native code instead of that.
        //
        [ResourceExposure(ResourceScope.None)]
        [MethodImplAttribute(MethodImplOptions.InternalCall)] 
        private extern static int GetRegistryLoggingValues(out bool loggingEnabled, out bool logToConsole, out int logLevel, out bool perfWarnings, out bool correctnessWarnings, out bool safeHandleStackTraces);
 
        private static void CheckRegistry() { 
            if (AppDomain.CurrentDomain.IsUnloadingForcedFinalize())
                return; 
            if (m_registryChecked) {
                return;
            }
 
            m_registryChecked = true;
 
            bool loggingEnabled; 
            bool logToConsole;
            int  logLevel; 
            int  facilityValue;
            facilityValue = GetRegistryLoggingValues(out loggingEnabled, out logToConsole, out logLevel, out m_perfWarnings, out m_correctnessWarnings, out m_safeHandleStackTraces);

            // Note we can get into some recursive situations where we call 
            // ourseves recursively through the .cctor.  That's why we have the
            // check for levelConversions == null. 
            if (!loggingEnabled) { 
                m_loggingNotEnabled = true;
            } 
            if (loggingEnabled && levelConversions!=null) {
                try {
                    //The values returned for the logging levels in the registry don't map nicely onto the
                    //values which we support internally (which are an approximation of the ones that 
                    //the System.Diagnostics namespace uses) so we have a quick map.
                    Assert(logLevel>=0 && logLevel<=10, "logLevel>=0 && logLevel<=10"); 
                    logLevel = (int)levelConversions[logLevel]; 

                    if (facilityValue>0) { 
                        for (int i=0; i
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
BCLDebug.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
