The Labs \ Source Viewer \ SSCLI \ System.Net \ NclTraceSource

  1. //------------------------------------------------------------------------------
  2. // <copyright file="Logging.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. namespace System.Net
  16. {
  17.    
  18.     using System.Collections;
  19.     using System.IO;
  20.     using System.Threading;
  21.     using System.Diagnostics;
  22.     using System.Security.Permissions;
  23.     using System.Runtime.InteropServices;
  24.     using System.Globalization;
  25.     using Microsoft.Win32;
  26.    
  27.    
  28.     internal class Logging
  29.     {
  30.        
  31.         private static bool s_LoggingEnabled = true;
  32.         private static bool s_LoggingInitialized;
  33.         private static bool s_AppDomainShutdown;
  34.        
  35.         private const int DefaultMaxDumpSize = 1024;
  36.         private const bool DefaultUseProtocolTextOnly = false;
  37.        
  38.         private const string AttributeNameMaxSize = "maxdatasize";
  39.         private const string AttributeNameTraceMode = "tracemode";
  40.         private static readonly string[] SupportedAttributes = new string[] {AttributeNameMaxSize, AttributeNameTraceMode};
  41.        
  42.         private const string AttributeValueProtocolOnly = "protocolonly";
  43.         //private const string AttributeValueIncludeHex = "includehex";
  44.        
  45.         private const string TraceSourceWebName = "System.Net";
  46.         private const string TraceSourceHttpListenerName = "System.Net.HttpListener";
  47.         private const string TraceSourceSocketsName = "System.Net.Sockets";
  48.         private const string TraceSourceCacheName = "System.Net.Cache";
  49.        
  50.         private static TraceSource s_WebTraceSource;
  51.         private static TraceSource s_HttpListenerTraceSource;
  52.         private static TraceSource s_SocketsTraceSource;
  53.         private static TraceSource s_CacheTraceSource;
  54.        
  55.         private Logging()
  56.         {
  57.         }
  58.        
  59.         private static object s_InternalSyncObject;
  60.        
  61.         private static object InternalSyncObject {
  62.             get {
  63.                 if (s_InternalSyncObject == null) {
  64.                     object o = new object();
  65.                     Interlocked.CompareExchange(ref s_InternalSyncObject, o, null);
  66.                 }
  67.                 return s_InternalSyncObject;
  68.             }
  69.         }
  70.        
  71.         static internal bool On {
  72.             get {
  73.                 if (!s_LoggingInitialized) {
  74.                     InitializeLogging();
  75.                 }
  76.                 return s_LoggingEnabled;
  77.             }
  78.         }
  79.        
  80.         static internal bool IsVerbose(TraceSource traceSource)
  81.         {
  82.             return ValidateSettings(traceSource, TraceEventType.Verbose);
  83.         }
  84.        
  85.         static internal TraceSource Web {
  86.             get {
  87.                 if (!s_LoggingInitialized) {
  88.                     InitializeLogging();
  89.                 }
  90.                 if (!s_LoggingEnabled) {
  91.                     return null;
  92.                 }
  93.                 return s_WebTraceSource;
  94.             }
  95.         }
  96.        
  97.         static internal TraceSource HttpListener {
  98.             get {
  99.                 if (!s_LoggingInitialized) {
  100.                     InitializeLogging();
  101.                 }
  102.                 if (!s_LoggingEnabled) {
  103.                     return null;
  104.                 }
  105.                 return s_HttpListenerTraceSource;
  106.             }
  107.         }
  108.        
  109.         static internal TraceSource Sockets {
  110.            
  111.             get {
  112.                 if (!s_LoggingInitialized) {
  113.                     InitializeLogging();
  114.                 }
  115.                 if (!s_LoggingEnabled) {
  116.                     return null;
  117.                 }
  118.                 return s_SocketsTraceSource;
  119.             }
  120.         }
  121.        
  122.         static internal TraceSource RequestCache {
  123.             get {
  124.                 if (!s_LoggingInitialized) {
  125.                     InitializeLogging();
  126.                 }
  127.                 if (!s_LoggingEnabled) {
  128.                     return null;
  129.                 }
  130.                 return s_CacheTraceSource;
  131.             }
  132.         }
  133.        
  134.         private static bool GetUseProtocolTextSetting(TraceSource traceSource)
  135.         {
  136.             bool useProtocolTextOnly = DefaultUseProtocolTextOnly;
  137.             if (traceSource.Attributes[AttributeNameTraceMode] == AttributeValueProtocolOnly) {
  138.                 useProtocolTextOnly = true;
  139.             }
  140.             return useProtocolTextOnly;
  141.         }
  142.        
  143.         private static int GetMaxDumpSizeSetting(TraceSource traceSource)
  144.         {
  145.             int maxDumpSize = DefaultMaxDumpSize;
  146.             if (traceSource.Attributes.ContainsKey(AttributeNameMaxSize)) {
  147.                 try {
  148.                     maxDumpSize = Int32.Parse(traceSource.Attributes[AttributeNameMaxSize], NumberFormatInfo.InvariantInfo);
  149.                 }
  150.                 catch (Exception exception) {
  151.                     if (exception is ThreadAbortException || exception is StackOverflowException || exception is OutOfMemoryException) {
  152.                         throw;
  153.                     }
  154.                     traceSource.Attributes[AttributeNameMaxSize] = maxDumpSize.ToString(NumberFormatInfo.InvariantInfo);
  155.                 }
  156.             }
  157.             return maxDumpSize;
  158.         }
  159.        
  160.         /// <devdoc>
  161.         /// <para>Sets up internal config settings for logging. (MUST be called under critsec) </para>
  162.         /// </devdoc>
  163.         private static void InitializeLogging()
  164.         {
  165.             lock (InternalSyncObject) {
  166.                 if (!s_LoggingInitialized) {
  167.                     bool loggingEnabled = false;
  168.                     s_WebTraceSource = new NclTraceSource(TraceSourceWebName);
  169.                     s_HttpListenerTraceSource = new NclTraceSource(TraceSourceHttpListenerName);
  170.                     s_SocketsTraceSource = new NclTraceSource(TraceSourceSocketsName);
  171.                     s_CacheTraceSource = new NclTraceSource(TraceSourceCacheName);
  172.                    
  173.                     GlobalLog.Print("Initalizating tracing");
  174.                    
  175.                     if (s_WebTraceSource.Switch.ShouldTrace(TraceEventType.Critical) || s_HttpListenerTraceSource.Switch.ShouldTrace(TraceEventType.Critical) || s_SocketsTraceSource.Switch.ShouldTrace(TraceEventType.Critical) || s_CacheTraceSource.Switch.ShouldTrace(TraceEventType.Critical)) {
  176.                         // if using Logging, then grab other logging switches
  177.                         loggingEnabled = true;
  178.                         AppDomain currentDomain = AppDomain.CurrentDomain;
  179.                         currentDomain.UnhandledException += new UnhandledExceptionEventHandler(UnhandledExceptionHandler);
  180.                         currentDomain.DomainUnload += new EventHandler(AppDomainUnloadEvent);
  181.                         currentDomain.ProcessExit += new EventHandler(ProcessExitEvent);
  182.                     }
  183.                     s_LoggingEnabled = loggingEnabled;
  184.                     s_LoggingInitialized = true;
  185.                 }
  186.             }
  187.         }
  188.        
  189.         private static void Close()
  190.         {
  191.             if (s_WebTraceSource != null)
  192.                 s_WebTraceSource.Close();
  193.             if (s_HttpListenerTraceSource != null)
  194.                 s_HttpListenerTraceSource.Close();
  195.             if (s_SocketsTraceSource != null)
  196.                 s_SocketsTraceSource.Close();
  197.             if (s_CacheTraceSource != null)
  198.                 s_CacheTraceSource.Close();
  199.         }
  200.        
  201.         /// <devdoc>
  202.         /// <para>Logs any unhandled exception through this event handler</para>
  203.         /// </devdoc>
  204.         private static void UnhandledExceptionHandler(object sender, UnhandledExceptionEventArgs args)
  205.         {
  206.             Exception e = (Exception)args.ExceptionObject;
  207.             Exception(Web, sender, "UnhandledExceptionHandler", e);
  208.         }
  209.        
  210.         private static void ProcessExitEvent(object sender, EventArgs e)
  211.         {
  212.             Close();
  213.             s_AppDomainShutdown = true;
  214.         }
  215.         /// <devdoc>
  216.         /// <para>Called when the system is shutting down, used to prevent additional logging post-shutdown</para>
  217.         /// </devdoc>
  218.         private static void AppDomainUnloadEvent(object sender, EventArgs e)
  219.         {
  220.             Close();
  221.             s_AppDomainShutdown = true;
  222.         }
  223.        
  224.        
  225.         /// <devdoc>
  226.         /// <para>Confirms logging is enabled, given current logging settings</para>
  227.         /// </devdoc>
  228.         private static bool ValidateSettings(TraceSource traceSource, TraceEventType traceLevel)
  229.         {
  230.             if (!s_LoggingEnabled) {
  231.                 return false;
  232.             }
  233.             if (!s_LoggingInitialized) {
  234.                 InitializeLogging();
  235.             }
  236.             if (traceSource == null || !traceSource.Switch.ShouldTrace(traceLevel)) {
  237.                 return false;
  238.             }
  239.             if (s_AppDomainShutdown) {
  240.                 return false;
  241.             }
  242.             return true;
  243.         }
  244.        
  245.         /// <devdoc>
  246.         /// <para>Converts an object to a normalized string that can be printed
  247.         /// takes System.Net.ObjectNamedFoo and coverts to ObjectNamedFoo </para>
  248.         /// </devdoc>
  249.         private static string GetObjectName(object obj)
  250.         {
  251.             string objName = obj.ToString();
  252.             try {
  253.                 if (!(obj is Uri)) {
  254.                     int index = objName.LastIndexOf('.') + 1;
  255.                     return objName.Substring(index, objName.Length - index);
  256.                 }
  257.                 else {
  258.                     return objName;
  259.                 }
  260.             }
  261.             catch (Exception exception) {
  262.                 if (exception is ThreadAbortException || exception is StackOverflowException || exception is OutOfMemoryException) {
  263.                     throw;
  264.                 }
  265.                 return objName;
  266.             }
  267.         }
  268.        
  269.         static internal uint GetThreadId()
  270.         {
  271.             uint threadId = UnsafeNclNativeMethods.GetCurrentThreadId();
  272.             if (threadId == 0) {
  273.                 threadId = (uint)Thread.CurrentThread.GetHashCode();
  274.             }
  275.             return threadId;
  276.         }
  277.        
  278.         static internal void PrintLine(TraceSource traceSource, TraceEventType eventType, int id, string msg)
  279.         {
  280.             string logHeader = "[" + GetThreadId().ToString("d4", CultureInfo.InvariantCulture) + "] ";
  281.             traceSource.TraceEvent(eventType, id, logHeader + msg);
  282.         }
  283.        
  284.         /// <devdoc>
  285.         /// <para>Indicates that two objects are getting used with one another</para>
  286.         /// </devdoc>
  287.         static internal void Associate(TraceSource traceSource, object objA, object objB)
  288.         {
  289.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  290.                 return;
  291.             }
  292.            
  293.             string lineA = GetObjectName(objA) + "#" + ValidationHelper.HashString(objA);
  294.             string lineB = GetObjectName(objB) + "#" + ValidationHelper.HashString(objB);
  295.            
  296.             PrintLine(traceSource, TraceEventType.Information, 0, "Associating " + lineA + " with " + lineB);
  297.         }
  298.        
  299.         /// <devdoc>
  300.         /// <para>Logs entrance to a function</para>
  301.         /// </devdoc>
  302.         static internal void Enter(TraceSource traceSource, object obj, string method, string param)
  303.         {
  304.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  305.                 return;
  306.             }
  307.             Enter(traceSource, GetObjectName(obj) + "#" + ValidationHelper.HashString(obj), method, param);
  308.         }
  309.        
  310.         /// <devdoc>
  311.         /// <para>Logs entrance to a function</para>
  312.         /// </devdoc>
  313.         static internal void Enter(TraceSource traceSource, object obj, string method, object paramObject)
  314.         {
  315.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  316.                 return;
  317.             }
  318.             Enter(traceSource, GetObjectName(obj) + "#" + ValidationHelper.HashString(obj), method, paramObject);
  319.         }
  320.        
  321.         /// <devdoc>
  322.         /// <para>Logs entrance to a function</para>
  323.         /// </devdoc>
  324.         static internal void Enter(TraceSource traceSource, string obj, string method, string param)
  325.         {
  326.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  327.                 return;
  328.             }
  329.             Enter(traceSource, obj + "::" + method + "(" + param + ")");
  330.         }
  331.        
  332.         /// <devdoc>
  333.         /// <para>Logs entrance to a function</para>
  334.         /// </devdoc>
  335.         static internal void Enter(TraceSource traceSource, string obj, string method, object paramObject)
  336.         {
  337.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  338.                 return;
  339.             }
  340.             string paramObjectValue = "";
  341.             if (paramObject != null) {
  342.                 paramObjectValue = GetObjectName(paramObject) + "#" + ValidationHelper.HashString(paramObject);
  343.             }
  344.             Enter(traceSource, obj + "::" + method + "(" + paramObjectValue + ")");
  345.         }
  346.        
  347.         /// <devdoc>
  348.         /// <para>Logs entrance to a function, indents and points that out</para>
  349.         /// </devdoc>
  350.         static internal void Enter(TraceSource traceSource, string method, string parameters)
  351.         {
  352.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  353.                 return;
  354.             }
  355.             Enter(traceSource, method + "(" + parameters + ")");
  356.         }
  357.        
  358.         /// <devdoc>
  359.         /// <para>Logs entrance to a function, indents and points that out</para>
  360.         /// </devdoc>
  361.         static internal void Enter(TraceSource traceSource, string msg)
  362.         {
  363.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  364.                 return;
  365.             }
  366.             // Trace.CorrelationManager.StartLogicalOperation();
  367.             PrintLine(traceSource, TraceEventType.Verbose, 0, msg);
  368.         }
  369.        
  370.         /// <devdoc>
  371.         /// <para>Logs exit from a function</para>
  372.         /// </devdoc>
  373.         static internal void Exit(TraceSource traceSource, object obj, string method, object retObject)
  374.         {
  375.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  376.                 return;
  377.             }
  378.             string retValue = "";
  379.             if (retObject != null) {
  380.                 retValue = GetObjectName(retObject) + "#" + ValidationHelper.HashString(retObject);
  381.             }
  382.             Exit(traceSource, obj, method, retValue);
  383.         }
  384.        
  385.         /// <devdoc>
  386.         /// <para>Logs exit from a function</para>
  387.         /// </devdoc>
  388.         static internal void Exit(TraceSource traceSource, string obj, string method, object retObject)
  389.         {
  390.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  391.                 return;
  392.             }
  393.             string retValue = "";
  394.             if (retObject != null) {
  395.                 retValue = GetObjectName(retObject) + "#" + ValidationHelper.HashString(retObject);
  396.             }
  397.             Exit(traceSource, obj, method, retValue);
  398.         }
  399.        
  400.        
  401.         /// <devdoc>
  402.         /// <para>Logs exit from a function</para>
  403.         /// </devdoc>
  404.         static internal void Exit(TraceSource traceSource, object obj, string method, string retValue)
  405.         {
  406.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  407.                 return;
  408.             }
  409.             Exit(traceSource, GetObjectName(obj) + "#" + ValidationHelper.HashString(obj), method, retValue);
  410.         }
  411.        
  412.         /// <devdoc>
  413.         /// <para>Logs exit from a function</para>
  414.         /// </devdoc>
  415.         static internal void Exit(TraceSource traceSource, string obj, string method, string retValue)
  416.         {
  417.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  418.                 return;
  419.             }
  420.             if (!ValidationHelper.IsBlankString(retValue)) {
  421.                 retValue = "\t-> " + retValue;
  422.             }
  423.             Exit(traceSource, obj + "::" + method + "() " + retValue);
  424.         }
  425.        
  426.         /// <devdoc>
  427.         /// <para>Logs exit from a function</para>
  428.         /// </devdoc>
  429.         static internal void Exit(TraceSource traceSource, string method, string parameters)
  430.         {
  431.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  432.                 return;
  433.             }
  434.             Exit(traceSource, method + "() " + parameters);
  435.         }
  436.        
  437.         /// <devdoc>
  438.         /// <para>Logs exit from a function</para>
  439.         /// </devdoc>
  440.         static internal void Exit(TraceSource traceSource, string msg)
  441.         {
  442.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  443.                 return;
  444.             }
  445.             PrintLine(traceSource, TraceEventType.Verbose, 0, "Exiting " + msg);
  446.             // Trace.CorrelationManager.StopLogicalOperation();
  447.         }
  448.        
  449.         /// <devdoc>
  450.         /// <para>Logs Exception, restores indenting</para>
  451.         /// </devdoc>
  452.         static internal void Exception(TraceSource traceSource, object obj, string method, Exception e)
  453.         {
  454.             if (!ValidateSettings(traceSource, TraceEventType.Error)) {
  455.                 return;
  456.             }
  457.             string infoLine = "Exception in the " + GetObjectName(obj) + "#" + ValidationHelper.HashString(obj) + "::" + method + " - ";
  458.             //Trace.IndentLevel = 0;
  459.             PrintLine(traceSource, TraceEventType.Error, 0, infoLine + e.Message);
  460.             if (!ValidationHelper.IsBlankString(e.StackTrace)) {
  461.                 PrintLine(traceSource, TraceEventType.Error, 0, e.StackTrace);
  462.             }
  463.             /*
  464.             if (e.InnerException != null)
  465.             {
  466.                 PrintLine(" ---- inner exception --- ");
  467.                 PrintLine(traceSource, TraceEventType.Error, 0, infoLine + e.InnerException.Message);
  468.                 PrintLine(traceSource, TraceEventType.Error, 0, infoLine + e.InnerException.Message);
  469.                 if (!ValidationHelper.IsBlankString(e.InnerException.StackTrace)) {
  470.                   PrintLine(traceSource, TraceEventType.Error, 0, e.InnerException.StackTrace);
  471.                 }
  472.                 PrintLine(" ---- End of inner exception --- ");
  473.             }
  474.             */           
  475.         }
  476.        
  477.         /// <devdoc>
  478.         /// <para>Logs an Info line</para>
  479.         /// </devdoc>
  480.         static internal void PrintInfo(TraceSource traceSource, string msg)
  481.         {
  482.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  483.                 return;
  484.             }
  485.             PrintLine(traceSource, TraceEventType.Information, 0, msg);
  486.         }
  487.        
  488.         /// <devdoc>
  489.         /// <para>Logs an Info line</para>
  490.         /// </devdoc>
  491.         static internal void PrintInfo(TraceSource traceSource, object obj, string msg)
  492.         {
  493.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  494.                 return;
  495.             }
  496.             PrintLine(traceSource, TraceEventType.Information, 0, GetObjectName(obj) + "#" + ValidationHelper.HashString(obj) + " - " + msg);
  497.         }
  498.        
  499.         /// <devdoc>
  500.         /// <para>Logs an Info line</para>
  501.         /// </devdoc>
  502.         static internal void PrintInfo(TraceSource traceSource, object obj, string method, string param)
  503.         {
  504.             if (!ValidateSettings(traceSource, TraceEventType.Information)) {
  505.                 return;
  506.             }
  507.             PrintLine(traceSource, TraceEventType.Information, 0, GetObjectName(obj) + "#" + ValidationHelper.HashString(obj) + "::" + method + "(" + param + ")");
  508.         }
  509.        
  510.         /// <devdoc>
  511.         /// <para>Logs a Warning line</para>
  512.         /// </devdoc>
  513.         static internal void PrintWarning(TraceSource traceSource, string msg)
  514.         {
  515.             if (!ValidateSettings(traceSource, TraceEventType.Warning)) {
  516.                 return;
  517.             }
  518.             PrintLine(traceSource, TraceEventType.Warning, 0, msg);
  519.         }
  520.        
  521.         /// <devdoc>
  522.         /// <para>Logs a Warning line</para>
  523.         /// </devdoc>
  524.         static internal void PrintWarning(TraceSource traceSource, object obj, string method, string msg)
  525.         {
  526.             if (!ValidateSettings(traceSource, TraceEventType.Warning)) {
  527.                 return;
  528.             }
  529.             PrintLine(traceSource, TraceEventType.Warning, 0, GetObjectName(obj) + "#" + ValidationHelper.HashString(obj) + "::" + method + "() - " + msg);
  530.         }
  531.        
  532.         /// <devdoc>
  533.         /// <para>Logs an Error line</para>
  534.         /// </devdoc>
  535.         static internal void PrintError(TraceSource traceSource, string msg)
  536.         {
  537.             if (!ValidateSettings(traceSource, TraceEventType.Error)) {
  538.                 return;
  539.             }
  540.             PrintLine(traceSource, TraceEventType.Error, 0, msg);
  541.         }
  542.        
  543.         /// <devdoc>
  544.         /// <para>Logs an Error line</para>
  545.         /// </devdoc>
  546.         static internal void PrintError(TraceSource traceSource, object obj, string method, string msg)
  547.         {
  548.             if (!ValidateSettings(traceSource, TraceEventType.Error)) {
  549.                 return;
  550.             }
  551.             PrintLine(traceSource, TraceEventType.Error, 0, GetObjectName(obj) + "#" + ValidationHelper.HashString(obj) + "::" + method + "() - " + msg);
  552.         }
  553.        
  554.         /// <devdoc>
  555.         /// <para>Marhsalls a buffer ptr to an array and then dumps the byte array to the log</para>
  556.         /// </devdoc>
  557.         static internal void Dump(TraceSource traceSource, object obj, string method, IntPtr bufferPtr, int length)
  558.         {
  559.             if (!ValidateSettings(traceSource, TraceEventType.Verbose) || bufferPtr == IntPtr.Zero || length < 0) {
  560.                 return;
  561.             }
  562.             byte[] buffer = new byte[length];
  563.             Marshal.Copy(bufferPtr, buffer, 0, length);
  564.             Dump(traceSource, obj, method, buffer, 0, length);
  565.         }
  566.        
  567.        
  568.         /// <devdoc>
  569.         /// <para>Dumps a byte array to the log</para>
  570.         /// </devdoc>
  571.         static internal void Dump(TraceSource traceSource, object obj, string method, byte[] buffer, int offset, int length)
  572.         {
  573.             if (!ValidateSettings(traceSource, TraceEventType.Verbose)) {
  574.                 return;
  575.             }
  576.             if (buffer == null) {
  577.                 PrintLine(traceSource, TraceEventType.Verbose, 0, "(null)");
  578.                 return;
  579.             }
  580.             if (offset > buffer.Length) {
  581.                 PrintLine(traceSource, TraceEventType.Verbose, 0, "(offset out of range)");
  582.                 return;
  583.             }
  584.             PrintLine(traceSource, TraceEventType.Verbose, 0, "Data from " + GetObjectName(obj) + "#" + ValidationHelper.HashString(obj) + "::" + method);
  585.             int maxDumpSize = GetMaxDumpSizeSetting(traceSource);
  586.             if (length > maxDumpSize) {
  587.                 PrintLine(traceSource, TraceEventType.Verbose, 0, "(printing " + maxDumpSize.ToString(NumberFormatInfo.InvariantInfo) + " out of " + length.ToString(NumberFormatInfo.InvariantInfo) + ")");
  588.                 length = maxDumpSize;
  589.             }
  590.             if ((length < 0) || (length > buffer.Length - offset)) {
  591.                 length = buffer.Length - offset;
  592.             }
  593.             if (GetUseProtocolTextSetting(traceSource)) {
  594.                 string output = "<<" + WebHeaderCollection.HeaderEncoding.GetString(buffer, offset, length) + ">>";
  595.                 PrintLine(traceSource, TraceEventType.Verbose, 0, output);
  596.                 return;
  597.             }
  598.             do {
  599.                 int n = Math.Min(length, 16);
  600.                 string disp = String.Format(CultureInfo.CurrentCulture, "{0:X8} : ", offset);
  601.                 for (int i = 0; i < n; ++i) {
  602.                     disp += String.Format(CultureInfo.CurrentCulture, "{0:X2}", buffer[offset + i]) + ((i == 7) ? '-' : ' ');
  603.                 }
  604.                 for (int i = n; i < 16; ++i) {
  605.                     disp += " ";
  606.                 }
  607.                 disp += ": ";
  608.                 for (int i = 0; i < n; ++i) {
  609.                     disp += ((buffer[offset + i] < 32) || (buffer[offset + i] > 126)) ? '.' : (char)(buffer[offset + i]);
  610.                 }
  611.                 PrintLine(traceSource, TraceEventType.Verbose, 0, disp);
  612.                 offset += n;
  613.                 length -= n;
  614.             }
  615.             while (length > 0);
  616.         }
  617.        
  618.         private class NclTraceSource : TraceSource
  619.         {
  620.             internal NclTraceSource(string name) : base(name)
  621.             {
  622.             }
  623.            
  624.             protected internal override string[] GetSupportedAttributes()
  625.             {
  626.                 return Logging.SupportedAttributes;
  627.             }
  628.         }
  629.     }
  630. }

Developer Fusion