The Labs \ Source Viewer \ SSCLI \ System.Diagnostics \ TraceInternal

  1. //------------------------------------------------------------------------------
  2. // <copyright file="TraceInternal.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.Diagnostics
  16. {
  17.     using System.Threading;
  18.     using System.IO;
  19.     using System.Security.Permissions;
  20.     using System.Collections;
  21.    
  22.     static internal class TraceInternal
  23.     {
  24.         private static TraceEventCache eventCache = null;
  25.         private static string appName = null;
  26.         static TraceListenerCollection listeners;
  27.         static bool autoFlush;
  28.         static bool useGlobalLock;
  29.         [ThreadStatic()]
  30.         static int indentLevel;
  31.         static int indentSize;
  32.         static bool settingsInitialized;
  33.         static bool defaultInitialized;
  34.        
  35.        
  36.         // this is internal so TraceSource can use it. We want to lock on the same object because both TraceInternal and
  37.         // TraceSource could be writing to the same listeners at the same time.
  38.         static internal readonly object critSec = new object();
  39.        
  40.         public static TraceListenerCollection Listeners {
  41.             get {
  42.                 InitializeSettings();
  43.                 if (listeners == null) {
  44.                     lock (critSec) {
  45.                         if (listeners == null) {
  46.                             // We only need to check that the main section exists. Everything else will get
  47.                             // created for us if it doesn't exist already.
  48.                             SystemDiagnosticsSection configSectionSav = DiagnosticsConfiguration.SystemDiagnosticsSection;
  49.                             if (configSectionSav != null) {
  50.                                 listeners = configSectionSav.Trace.Listeners.GetRuntimeObject();
  51.                             }
  52.                             else {
  53.                                 // If machine.config was deleted the code will get to here
  54.                                 // supply at least something to prevent the world from coming to
  55.                                 // an abrupt end.
  56.                                 listeners = new TraceListenerCollection();
  57.                                 TraceListener defaultListener = new DefaultTraceListener();
  58.                                 defaultListener.IndentLevel = indentLevel;
  59.                                 defaultListener.IndentSize = indentSize;
  60.                                 listeners.Add(defaultListener);
  61.                             }
  62.                         }
  63.                     }
  64.                 }
  65.                 return listeners;
  66.             }
  67.         }
  68.        
  69.         static internal string AppName {
  70.             get {
  71.                 if (appName == null) {
  72.                     new EnvironmentPermission(EnvironmentPermissionAccess.Read, "Path").Assert();
  73.                     appName = Path.GetFileName(Environment.GetCommandLineArgs()[0]);
  74.                 }
  75.                 return appName;
  76.             }
  77.         }
  78.        
  79.         public static bool AutoFlush {
  80.             get {
  81.                 InitializeSettings();
  82.                 return autoFlush;
  83.             }
  84.            
  85.             set {
  86.                 InitializeSettings();
  87.                 autoFlush = value;
  88.             }
  89.         }
  90.        
  91.         public static bool UseGlobalLock {
  92.             get {
  93.                 InitializeSettings();
  94.                 return useGlobalLock;
  95.             }
  96.            
  97.             set {
  98.                 InitializeSettings();
  99.                 useGlobalLock = value;
  100.             }
  101.         }
  102.        
  103.         static internal TraceEventCache EventCache {
  104.             get {
  105.                 if (eventCache == null)
  106.                     eventCache = new TraceEventCache();
  107.                
  108.                 return eventCache;
  109.             }
  110.         }
  111.        
  112.         public static int IndentLevel {
  113.             get { return indentLevel; }
  114.            
  115.             set {
  116.                 // Use global lock
  117.                 lock (critSec) {
  118.                     // We don't want to throw here -- it is very bad form to have debug or trace
  119.                     // code throw exceptions!
  120.                     if (value < 0) {
  121.                         value = 0;
  122.                     }
  123.                     indentLevel = value;
  124.                    
  125.                     if (listeners != null) {
  126.                         foreach (TraceListener listener in Listeners) {
  127.                             listener.IndentLevel = indentLevel;
  128.                         }
  129.                     }
  130.                 }
  131.             }
  132.         }
  133.        
  134.         public static int IndentSize {
  135.             get {
  136.                 InitializeSettings();
  137.                 return indentSize;
  138.             }
  139.            
  140.             set {
  141.                 InitializeSettings();
  142.                 SetIndentSize(value);
  143.             }
  144.         }
  145.        
  146.         static void SetIndentSize(int value)
  147.         {
  148.             // Use global lock
  149.             lock (critSec) {
  150.                 // We don't want to throw here -- it is very bad form to have debug or trace
  151.                 // code throw exceptions!
  152.                 if (value < 0) {
  153.                     value = 0;
  154.                 }
  155.                
  156.                 indentSize = value;
  157.                
  158.                 if (listeners != null) {
  159.                     foreach (TraceListener listener in Listeners) {
  160.                         listener.IndentSize = indentSize;
  161.                     }
  162.                 }
  163.             }
  164.         }
  165.        
  166.         public static void Indent()
  167.         {
  168.             // Use global lock
  169.             lock (critSec) {
  170.                 InitializeSettings();
  171.                 if (indentLevel < Int32.MaxValue) {
  172.                     indentLevel++;
  173.                 }
  174.                 foreach (TraceListener listener in Listeners) {
  175.                     listener.IndentLevel = indentLevel;
  176.                 }
  177.             }
  178.         }
  179.        
  180.         public static void Unindent()
  181.         {
  182.             // Use global lock
  183.             lock (critSec) {
  184.                 InitializeSettings();
  185.                 if (indentLevel > 0) {
  186.                     indentLevel--;
  187.                 }
  188.                 foreach (TraceListener listener in Listeners) {
  189.                     listener.IndentLevel = indentLevel;
  190.                 }
  191.             }
  192.         }
  193.        
  194.         public static void Flush()
  195.         {
  196.             if (listeners != null) {
  197.                 if (UseGlobalLock) {
  198.                     lock (critSec) {
  199.                         foreach (TraceListener listener in Listeners) {
  200.                             listener.Flush();
  201.                         }
  202.                     }
  203.                 }
  204.                 else {
  205.                     foreach (TraceListener listener in Listeners) {
  206.                         if (!listener.IsThreadSafe) {
  207.                             lock (listener) {
  208.                                 listener.Flush();
  209.                             }
  210.                         }
  211.                         else {
  212.                             listener.Flush();
  213.                         }
  214.                     }
  215.                 }
  216.             }
  217.         }
  218.        
  219.         public static void Close()
  220.         {
  221.             if (listeners != null) {
  222.                 // Use global lock
  223.                 lock (critSec) {
  224.                     foreach (TraceListener listener in Listeners) {
  225.                         listener.Close();
  226.                     }
  227.                 }
  228.             }
  229.         }
  230.        
  231.         public static void Assert(bool condition)
  232.         {
  233.             if (condition)
  234.                 return;
  235.             Fail(string.Empty);
  236.         }
  237.        
  238.         public static void Assert(bool condition, string message)
  239.         {
  240.             if (condition)
  241.                 return;
  242.             Fail(message);
  243.         }
  244.        
  245.         public static void Assert(bool condition, string message, string detailMessage)
  246.         {
  247.             if (condition)
  248.                 return;
  249.             Fail(message, detailMessage);
  250.         }
  251.        
  252.         public static void Fail(string message)
  253.         {
  254.             if (UseGlobalLock) {
  255.                 lock (critSec) {
  256.                     foreach (TraceListener listener in Listeners) {
  257.                         listener.Fail(message);
  258.                         if (AutoFlush)
  259.                             listener.Flush();
  260.                     }
  261.                 }
  262.             }
  263.             else {
  264.                 foreach (TraceListener listener in Listeners) {
  265.                     if (!listener.IsThreadSafe) {
  266.                         lock (listener) {
  267.                             listener.Fail(message);
  268.                             if (AutoFlush)
  269.                                 listener.Flush();
  270.                         }
  271.                     }
  272.                     else {
  273.                         listener.Fail(message);
  274.                         if (AutoFlush)
  275.                             listener.Flush();
  276.                     }
  277.                 }
  278.             }
  279.         }
  280.        
  281.         public static void Fail(string message, string detailMessage)
  282.         {
  283.             if (UseGlobalLock) {
  284.                 lock (critSec) {
  285.                     foreach (TraceListener listener in Listeners) {
  286.                         listener.Fail(message, detailMessage);
  287.                         if (AutoFlush)
  288.                             listener.Flush();
  289.                     }
  290.                 }
  291.             }
  292.             else {
  293.                 foreach (TraceListener listener in Listeners) {
  294.                     if (!listener.IsThreadSafe) {
  295.                         lock (listener) {
  296.                             listener.Fail(message, detailMessage);
  297.                             if (AutoFlush)
  298.                                 listener.Flush();
  299.                         }
  300.                     }
  301.                     else {
  302.                         listener.Fail(message, detailMessage);
  303.                         if (AutoFlush)
  304.                             listener.Flush();
  305.                     }
  306.                 }
  307.             }
  308.         }
  309.        
  310.         private static void InitializeSettings()
  311.         {
  312.             if (!settingsInitialized || (defaultInitialized && DiagnosticsConfiguration.IsInitialized())) {
  313.                 defaultInitialized = DiagnosticsConfiguration.IsInitializing();
  314.                
  315.                 // Getting IndentSize and AutoFlush will load config on demand.
  316.                 // If we load config and there are trace listeners added, we'll
  317.                 // end up recursing, but that recursion will be stopped in
  318.                 // DiagnosticsConfiguration.Initialize()
  319.                 SetIndentSize(DiagnosticsConfiguration.IndentSize);
  320.                 autoFlush = DiagnosticsConfiguration.AutoFlush;
  321.                 useGlobalLock = DiagnosticsConfiguration.UseGlobalLock;
  322.                 settingsInitialized = true;
  323.             }
  324.         }
  325.        
  326.         public static void TraceEvent(TraceEventType eventType, int id, string format, params object[] args)
  327.         {
  328.             if (UseGlobalLock) {
  329.                 lock (critSec) {
  330.                     if (args == null) {
  331.                         foreach (TraceListener listener in Listeners) {
  332.                             listener.TraceEvent(EventCache, AppName, eventType, id, format);
  333.                             if (AutoFlush)
  334.                                 listener.Flush();
  335.                         }
  336.                     }
  337.                     else {
  338.                         foreach (TraceListener listener in Listeners) {
  339.                             listener.TraceEvent(EventCache, AppName, eventType, id, format, args);
  340.                             if (AutoFlush)
  341.                                 listener.Flush();
  342.                         }
  343.                     }
  344.                 }
  345.             }
  346.             else {
  347.                 if (args == null) {
  348.                     foreach (TraceListener listener in Listeners) {
  349.                         if (!listener.IsThreadSafe) {
  350.                             lock (listener) {
  351.                                 listener.TraceEvent(EventCache, AppName, eventType, id, format);
  352.                                 if (AutoFlush)
  353.                                     listener.Flush();
  354.                             }
  355.                         }
  356.                         else {
  357.                             listener.TraceEvent(EventCache, AppName, eventType, id, format);
  358.                             if (AutoFlush)
  359.                                 listener.Flush();
  360.                         }
  361.                     }
  362.                 }
  363.                 else {
  364.                     foreach (TraceListener listener in Listeners) {
  365.                         if (!listener.IsThreadSafe) {
  366.                             lock (listener) {
  367.                                 listener.TraceEvent(EventCache, AppName, eventType, id, format, args);
  368.                                 if (AutoFlush)
  369.                                     listener.Flush();
  370.                             }
  371.                         }
  372.                         else {
  373.                             listener.TraceEvent(EventCache, AppName, eventType, id, format, args);
  374.                             if (AutoFlush)
  375.                                 listener.Flush();
  376.                         }
  377.                     }
  378.                 }
  379.             }
  380.             EventCache.Clear();
  381.         }
  382.        
  383.        
  384.         public static void Write(string message)
  385.         {
  386.             if (UseGlobalLock) {
  387.                 lock (critSec) {
  388.                     foreach (TraceListener listener in Listeners) {
  389.                         listener.Write(message);
  390.                         if (AutoFlush)
  391.                             listener.Flush();
  392.                     }
  393.                 }
  394.             }
  395.             else {
  396.                 foreach (TraceListener listener in Listeners) {
  397.                     if (!listener.IsThreadSafe) {
  398.                         lock (listener) {
  399.                             listener.Write(message);
  400.                             if (AutoFlush)
  401.                                 listener.Flush();
  402.                         }
  403.                     }
  404.                     else {
  405.                         listener.Write(message);
  406.                         if (AutoFlush)
  407.                             listener.Flush();
  408.                     }
  409.                 }
  410.             }
  411.         }
  412.        
  413.         public static void Write(object value)
  414.         {
  415.             if (UseGlobalLock) {
  416.                 lock (critSec) {
  417.                     foreach (TraceListener listener in Listeners) {
  418.                         listener.Write(value);
  419.                         if (AutoFlush)
  420.                             listener.Flush();
  421.                     }
  422.                 }
  423.             }
  424.             else {
  425.                 foreach (TraceListener listener in Listeners) {
  426.                     if (!listener.IsThreadSafe) {
  427.                         lock (listener) {
  428.                             listener.Write(value);
  429.                             if (AutoFlush)
  430.                                 listener.Flush();
  431.                         }
  432.                     }
  433.                     else {
  434.                         listener.Write(value);
  435.                         if (AutoFlush)
  436.                             listener.Flush();
  437.                     }
  438.                 }
  439.             }
  440.         }
  441.        
  442.         public static void Write(string message, string category)
  443.         {
  444.             if (UseGlobalLock) {
  445.                 lock (critSec) {
  446.                     foreach (TraceListener listener in Listeners) {
  447.                         listener.Write(message, category);
  448.                         if (AutoFlush)
  449.                             listener.Flush();
  450.                     }
  451.                 }
  452.             }
  453.             else {
  454.                 foreach (TraceListener listener in Listeners) {
  455.                     if (!listener.IsThreadSafe) {
  456.                         lock (listener) {
  457.                             listener.Write(message, category);
  458.                             if (AutoFlush)
  459.                                 listener.Flush();
  460.                         }
  461.                     }
  462.                     else {
  463.                         listener.Write(message, category);
  464.                         if (AutoFlush)
  465.                             listener.Flush();
  466.                     }
  467.                 }
  468.             }
  469.         }
  470.        
  471.         public static void Write(object value, string category)
  472.         {
  473.             if (UseGlobalLock) {
  474.                 lock (critSec) {
  475.                     foreach (TraceListener listener in Listeners) {
  476.                         listener.Write(value, category);
  477.                         if (AutoFlush)
  478.                             listener.Flush();
  479.                     }
  480.                 }
  481.             }
  482.             else {
  483.                 foreach (TraceListener listener in Listeners) {
  484.                     if (!listener.IsThreadSafe) {
  485.                         lock (listener) {
  486.                             listener.Write(value, category);
  487.                             if (AutoFlush)
  488.                                 listener.Flush();
  489.                         }
  490.                     }
  491.                     else {
  492.                         listener.Write(value, category);
  493.                         if (AutoFlush)
  494.                             listener.Flush();
  495.                     }
  496.                 }
  497.             }
  498.         }
  499.        
  500.         public static void WriteLine(string message)
  501.         {
  502.             if (UseGlobalLock) {
  503.                 lock (critSec) {
  504.                     foreach (TraceListener listener in Listeners) {
  505.                         listener.WriteLine(message);
  506.                         if (AutoFlush)
  507.                             listener.Flush();
  508.                     }
  509.                 }
  510.             }
  511.             else {
  512.                 foreach (TraceListener listener in Listeners) {
  513.                     if (!listener.IsThreadSafe) {
  514.                         lock (listener) {
  515.                             listener.WriteLine(message);
  516.                             if (AutoFlush)
  517.                                 listener.Flush();
  518.                         }
  519.                     }
  520.                     else {
  521.                         listener.WriteLine(message);
  522.                         if (AutoFlush)
  523.                             listener.Flush();
  524.                     }
  525.                 }
  526.             }
  527.         }
  528.        
  529.         public static void WriteLine(object value)
  530.         {
  531.             if (UseGlobalLock) {
  532.                 lock (critSec) {
  533.                     foreach (TraceListener listener in Listeners) {
  534.                         listener.WriteLine(value);
  535.                         if (AutoFlush)
  536.                             listener.Flush();
  537.                     }
  538.                 }
  539.             }
  540.             else {
  541.                 foreach (TraceListener listener in Listeners) {
  542.                     if (!listener.IsThreadSafe) {
  543.                         lock (listener) {
  544.                             listener.WriteLine(value);
  545.                             if (AutoFlush)
  546.                                 listener.Flush();
  547.                         }
  548.                     }
  549.                     else {
  550.                         listener.WriteLine(value);
  551.                         if (AutoFlush)
  552.                             listener.Flush();
  553.                     }
  554.                 }
  555.             }
  556.         }
  557.        
  558.         public static void WriteLine(string message, string category)
  559.         {
  560.             if (UseGlobalLock) {
  561.                 lock (critSec) {
  562.                     foreach (TraceListener listener in Listeners) {
  563.                         listener.WriteLine(message, category);
  564.                         if (AutoFlush)
  565.                             listener.Flush();
  566.                     }
  567.                 }
  568.             }
  569.             else {
  570.                 foreach (TraceListener listener in Listeners) {
  571.                     if (!listener.IsThreadSafe) {
  572.                         lock (listener) {
  573.                             listener.WriteLine(message, category);
  574.                             if (AutoFlush)
  575.                                 listener.Flush();
  576.                         }
  577.                     }
  578.                     else {
  579.                         listener.WriteLine(message, category);
  580.                         if (AutoFlush)
  581.                             listener.Flush();
  582.                     }
  583.                 }
  584.             }
  585.         }
  586.        
  587.         public static void WriteLine(object value, string category)
  588.         {
  589.             if (UseGlobalLock) {
  590.                 lock (critSec) {
  591.                     foreach (TraceListener listener in Listeners) {
  592.                         listener.WriteLine(value, category);
  593.                         if (AutoFlush)
  594.                             listener.Flush();
  595.                     }
  596.                 }
  597.             }
  598.             else {
  599.                 foreach (TraceListener listener in Listeners) {
  600.                     if (!listener.IsThreadSafe) {
  601.                         lock (listener) {
  602.                             listener.WriteLine(value, category);
  603.                             if (AutoFlush)
  604.                                 listener.Flush();
  605.                         }
  606.                     }
  607.                     else {
  608.                         listener.WriteLine(value, category);
  609.                         if (AutoFlush)
  610.                             listener.Flush();
  611.                     }
  612.                 }
  613.             }
  614.         }
  615.        
  616.         public static void WriteIf(bool condition, string message)
  617.         {
  618.             if (condition)
  619.                 Write(message);
  620.         }
  621.        
  622.         public static void WriteIf(bool condition, object value)
  623.         {
  624.             if (condition)
  625.                 Write(value);
  626.         }
  627.        
  628.         public static void WriteIf(bool condition, string message, string category)
  629.         {
  630.             if (condition)
  631.                 Write(message, category);
  632.         }
  633.        
  634.         public static void WriteIf(bool condition, object value, string category)
  635.         {
  636.             if (condition)
  637.                 Write(value, category);
  638.         }
  639.        
  640.         public static void WriteLineIf(bool condition, string message)
  641.         {
  642.             if (condition)
  643.                 WriteLine(message);
  644.         }
  645.        
  646.         public static void WriteLineIf(bool condition, object value)
  647.         {
  648.             if (condition)
  649.                 WriteLine(value);
  650.         }
  651.        
  652.         public static void WriteLineIf(bool condition, string message, string category)
  653.         {
  654.             if (condition)
  655.                 WriteLine(message, category);
  656.         }
  657.        
  658.         public static void WriteLineIf(bool condition, object value, string category)
  659.         {
  660.             if (condition)
  661.                 WriteLine(value, category);
  662.         }
  663.     }
  664. }

Developer Fusion