Logging.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / SystemNet / Net / Logging.cs / 1305376 / Logging.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 
namespace System.Net
{ 
    using System.Collections; 
    using System.IO;
    using System.Threading; 
    using System.Diagnostics;
    using System.Security.Permissions;
    using System.Runtime.InteropServices;
    using System.Globalization; 
    using Microsoft.Win32;
    using System.Text; 
    internal static class Logging 
    {
        private static P2PTraceSource s_P2PTraceSource; 
        // 
        // 
        // 
        //  
        // 
        //  
        [System.Security.SecurityCritical] 
        static Logging()
        { 
            s_P2PTraceSource = new P2PTraceSource();
            if (s_P2PTraceSource.Switch.ShouldTrace(TraceEventType.Critical))
            {
                AppDomain currentDomain = AppDomain.CurrentDomain; 
                currentDomain.ProcessExit += new EventHandler(ProcessExitEventHandler);
                //currentDomain.UnhandledException += new UnhandledExceptionEventHandler(UnhandledExceptionEventHandler); 
                currentDomain.DomainUnload += new EventHandler(DomainUnloadEventHandler); 
            }
        } 
        // 
        // 
        // 
        [System.Security.SecurityCritical] 
        private static void DomainUnloadEventHandler(object sender, EventArgs e)
        { 
            Close(); 
        }
 
        /*
        private static void UnhandledExceptionEventHandler(object sender, UnhandledExceptionEventArgs e)
        {
            s_P2PTraceSource.TraceEvent(TraceEventType.Critical, UNHANDLED_EXCEPTION_EVENT_ID, "Unhandled Exception {0}", e.ExceptionObject); 
        }
        */ 
        //  
        // 
        //  
        [System.Security.SecurityCritical]
        private static void ProcessExitEventHandler(object sender, EventArgs e)
        {
            Close(); 
        }
        //  
        //  
        // 
        [System.Security.SecurityCritical] 
        private static void Close()
        {
            s_P2PTraceSource.Close();
        } 
        //private Logging() {}
        internal static P2PTraceSource P2PTraceSource 
        { 
            get
            { 
                return s_P2PTraceSource;
            }
        }
 
        internal static void Enter(TraceSource source, string method)
        { 
            if(source.Switch.ShouldTrace(TraceEventType.Verbose)) 
            {
                source.TraceEvent(TraceEventType.Verbose, 0, "Entering --> " + method); 
            }
        }
        internal static void Leave(TraceSource source, string message)
        { 
            if (source.Switch.ShouldTrace(TraceEventType.Verbose))
            { 
                source.TraceEvent(TraceEventType.Verbose, 0, "Leaving <-- " + message); 
            }
        } 

        /*
        internal static void Enter(TraceSource source, string type, object obj, string method)
        { 

        } 
        internal static void Enter(TraceSource source, string type, object obj, string method, params object[] args) 
        {
 
        }
         * */

        internal static void DumpData(TraceSource source, TraceEventType eventType, int maxDataSize, byte[] buffer, int offset, int length) 
        {
            if (buffer == null || 
                    buffer.Length == 0 || 
                    offset > buffer.Length)
            { 
                return;
            }
            if (length > maxDataSize)
            { 
                source.TraceEvent(eventType, 0, "dumping {0} of {1} bytes", maxDataSize, length);
                length = maxDataSize; 
            } 
            if ((length < 0) || (length > buffer.Length - offset))
            { 
                length = buffer.Length - offset;
            }
            do
            { 
                int n = Math.Min(length, 16);
                StringBuilder sb = new StringBuilder(); 
                sb.Append(String.Format(CultureInfo.CurrentCulture, "{0:X8} : ", offset)); 
                for (int i = 0; i < n; ++i)
                { 
                    sb.Append(String.Format(CultureInfo.CurrentCulture, "{0:X2}", buffer[offset + i]) + ((i == 7) ? '-' : ' '));
                }
                for (int i = n; i < 16; ++i)
                { 
                    sb.Append("   ");
                } 
                sb.Append(": "); 
                for (int i = 0; i < n; ++i)
                { 
                    sb.Append(((buffer[offset + i] < 0x20) || (buffer[offset + i] > 0x7e))
                                ? '.'
                                : (char)(buffer[offset + i]));
                } 
                source.TraceEvent(eventType, 0, sb.ToString());
                offset += n; 
                length -= n; 
            } while (length > 0);
 
        }

    }
 
    internal class P2PTraceSource : TraceSource
    { 
        private const string P2PTraceSourceName = "System.Net.PeerToPeer"; 
        private const int DefaultMaxDataSize = 1024;
        private const string AttributeNameMaxDataSize = "maxdatasize"; 
        private static readonly string[] P2PTraceSourceSupportedAttributes = new string[] { AttributeNameMaxDataSize };
        private int m_maxDataSize = DefaultMaxDataSize;

        internal P2PTraceSource() :base(P2PTraceSourceName) 
        {
            if (Attributes.ContainsKey(AttributeNameMaxDataSize)) 
            { 
                try{
                    m_maxDataSize = Int32.Parse(Attributes[AttributeNameMaxDataSize], NumberFormatInfo.InvariantInfo); 
                }
                catch (Exception exception) {
                    if (exception is ThreadAbortException || exception is StackOverflowException || exception is OutOfMemoryException) {
                        throw; 
                    }
                } 
            } 
        }
        protected  override string[] GetSupportedAttributes() 
        {
            return P2PTraceSourceSupportedAttributes;
        }
 
        internal int MaxDataSize
        { 
            get 
            {
                return m_maxDataSize; 
            }
        }
    }
 

} 

// 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
Logging.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
