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

  1. //------------------------------------------------------------------------------
  2. // <copyright file="TraceListeners.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. /*
  16. */
  17. namespace System.Diagnostics
  18. {
  19.     using System;
  20.     using System.Collections;
  21.     using Microsoft.Win32;
  22.    
  23.     /// <devdoc>
  24.     /// <para>Provides a thread-safe list of <see cref='System.Diagnostics.TraceListenerCollection'/>. A thread-safe list is synchronized.</para>
  25.     /// </devdoc>
  26.     public class TraceListenerCollection : IList
  27.     {
  28.         ArrayList list;
  29.        
  30.         internal TraceListenerCollection()
  31.         {
  32.             list = new ArrayList(1);
  33.         }
  34.        
  35.         /// <devdoc>
  36.         /// <para>Gets or sets the <see cref='TraceListener'/> at
  37.         /// the specified index.</para>
  38.         /// </devdoc>
  39.         public TraceListener this[int i]
  40.         {
  41.             get { return (TraceListener)list[i]; }
  42.            
  43.             set {
  44.                 InitializeListener(value);
  45.                 list[i] = value;
  46.             }
  47.         }
  48.        
  49.         /// <devdoc>
  50.         /// <para>Gets the first <see cref='System.Diagnostics.TraceListener'/> in the list with the specified name.</para>
  51.         /// </devdoc>
  52.         public TraceListener this[string name]
  53.         {
  54.             get {
  55.                 foreach (TraceListener listener in this) {
  56.                     if (listener.Name == name)
  57.                         return listener;
  58.                 }
  59.                 return null;
  60.             }
  61.         }
  62.        
  63.         /// <devdoc>
  64.         /// <para>
  65.         /// Gets the number of listeners in the list.
  66.         /// </para>
  67.         /// </devdoc>
  68.         public int Count {
  69.             get { return list.Count; }
  70.         }
  71.        
  72.         /// <devdoc>
  73.         /// <para>Adds a <see cref='System.Diagnostics.TraceListener'/> to the list.</para>
  74.         /// </devdoc>
  75.         public int Add(TraceListener listener)
  76.         {
  77.             InitializeListener(listener);
  78.            
  79.             lock (TraceInternal.critSec) {
  80.                 return list.Add(listener);
  81.             }
  82.         }
  83.        
  84.         /// <devdoc>
  85.         /// <para>[To be supplied.]</para>
  86.         /// </devdoc>
  87.         public void AddRange(TraceListener[] value)
  88.         {
  89.             if (value == null) {
  90.                 throw new ArgumentNullException("value");
  91.             }
  92.             for (int i = 0; ((i) < (value.Length)); i = ((i)+(1))) {
  93.                 this.Add(value[i]);
  94.             }
  95.         }
  96.        
  97.         /// <devdoc>
  98.         /// <para>[To be supplied.]</para>
  99.         /// </devdoc>
  100.         public void AddRange(TraceListenerCollection value)
  101.         {
  102.             if (value == null) {
  103.                 throw new ArgumentNullException("value");
  104.             }
  105.             int currentCount = value.Count;
  106.             for (int i = 0; i < currentCount; i = ((i)+(1))) {
  107.                 this.Add(value[i]);
  108.             }
  109.         }
  110.        
  111.         /// <devdoc>
  112.         /// <para>
  113.         /// Clears all the listeners from the
  114.         /// list.
  115.         /// </para>
  116.         /// </devdoc>
  117.         public void Clear()
  118.         {
  119.             list = new ArrayList();
  120.         }
  121.        
  122.         /// <devdoc>
  123.         /// <para>Checks whether the list contains the specified
  124.         /// listener.</para>
  125.         /// </devdoc>
  126.         public bool Contains(TraceListener listener)
  127.         {
  128.             return ((IList)this).Contains(listener);
  129.         }
  130.        
  131.         /// <devdoc>
  132.         /// <para>Copies a section of the current <see cref='System.Diagnostics.TraceListenerCollection'/> list to the specified array at the specified
  133.         /// index.</para>
  134.         /// </devdoc>
  135.         public void CopyTo(TraceListener[] listeners, int index)
  136.         {
  137.             ((ICollection)this).CopyTo((Array)listeners, index);
  138.         }
  139.        
  140.         /// <devdoc>
  141.         /// <para>
  142.         /// Gets an enumerator for this list.
  143.         /// </para>
  144.         /// </devdoc>
  145.         public IEnumerator GetEnumerator()
  146.         {
  147.             return list.GetEnumerator();
  148.         }
  149.        
  150.         internal void InitializeListener(TraceListener listener)
  151.         {
  152.             if (listener == null)
  153.                 throw new ArgumentNullException("listener");
  154.            
  155.             listener.IndentSize = TraceInternal.IndentSize;
  156.             listener.IndentLevel = TraceInternal.IndentLevel;
  157.         }
  158.        
  159.         /// <devdoc>
  160.         /// <para>Gets the index of the specified listener.</para>
  161.         /// </devdoc>
  162.         public int IndexOf(TraceListener listener)
  163.         {
  164.             return ((IList)this).IndexOf(listener);
  165.         }
  166.        
  167.         /// <devdoc>
  168.         /// <para>Inserts the listener at the specified index.</para>
  169.         /// </devdoc>
  170.         public void Insert(int index, TraceListener listener)
  171.         {
  172.             InitializeListener(listener);
  173.             lock (TraceInternal.critSec) {
  174.                 list.Insert(index, listener);
  175.             }
  176.         }
  177.        
  178.         /// <devdoc>
  179.         /// <para>
  180.         /// Removes the specified instance of the <see cref='System.Diagnostics.TraceListener'/> class from the list.
  181.         /// </para>
  182.         /// </devdoc>
  183.         public void Remove(TraceListener listener)
  184.         {
  185.             ((IList)this).Remove(listener);
  186.         }
  187.        
  188.         /// <devdoc>
  189.         /// <para>Removes the first listener in the list that has the
  190.         /// specified name.</para>
  191.         /// </devdoc>
  192.         public void Remove(string name)
  193.         {
  194.             TraceListener listener = this[name];
  195.             if (listener != null)
  196.                 ((IList)this).Remove(listener);
  197.         }
  198.        
  199.         /// <devdoc>
  200.         /// <para>Removes the <see cref='System.Diagnostics.TraceListener'/> at the specified index.</para>
  201.         /// </devdoc>
  202.         public void RemoveAt(int index)
  203.         {
  204.             lock (TraceInternal.critSec) {
  205.                 list.RemoveAt(index);
  206.             }
  207.         }
  208.        
  209.         /// <internalonly/>
  210.         object IList.this[int index]
  211.         {
  212.             get { return list[index]; }
  213.            
  214.             set {
  215.                 TraceListener listener = value as TraceListener;
  216.                 if (listener == null)
  217.                     throw new ArgumentException(SR.GetString(SR.MustAddListener), "value");
  218.                 InitializeListener(listener);
  219.                 list[index] = listener;
  220.                
  221.             }
  222.         }
  223.        
  224.         /// <internalonly/>
  225.         bool IList.IsReadOnly {
  226.             get { return false; }
  227.         }
  228.        
  229.         /// <internalonly/>
  230.         bool IList.IsFixedSize {
  231.             get { return false; }
  232.         }
  233.        
  234.         /// <internalonly/>
  235.         int IList.Add(object value)
  236.         {
  237.             TraceListener listener = value as TraceListener;
  238.             if (listener == null)
  239.                 throw new ArgumentException(SR.GetString(SR.MustAddListener), "value");
  240.            
  241.             InitializeListener(listener);
  242.            
  243.             lock (TraceInternal.critSec) {
  244.                 return list.Add(value);
  245.             }
  246.         }
  247.        
  248.         /// <internalonly/>
  249.         bool IList.Contains(object value)
  250.         {
  251.             return list.Contains(value);
  252.         }
  253.        
  254.         /// <internalonly/>
  255.         int IList.IndexOf(object value)
  256.         {
  257.             return list.IndexOf(value);
  258.         }
  259.        
  260.         /// <internalonly/>
  261.         void IList.Insert(int index, object value)
  262.         {
  263.             TraceListener listener = value as TraceListener;
  264.             if (listener == null)
  265.                 throw new ArgumentException(SR.GetString(SR.MustAddListener), "value");
  266.            
  267.             InitializeListener(listener);
  268.            
  269.             lock (TraceInternal.critSec) {
  270.                 list.Insert(index, value);
  271.             }
  272.         }
  273.        
  274.         /// <internalonly/>
  275.         void IList.Remove(object value)
  276.         {
  277.             lock (TraceInternal.critSec) {
  278.                 list.Remove(value);
  279.             }
  280.         }
  281.        
  282.         /// <internalonly/>
  283.         object ICollection.SyncRoot {
  284.             get { return this; }
  285.         }
  286.        
  287.         /// <internalonly/>
  288.         bool ICollection.IsSynchronized {
  289.             get { return true; }
  290.         }
  291.        
  292.         /// <internalonly/>
  293.         void ICollection.CopyTo(Array array, int index)
  294.         {
  295.             lock (TraceInternal.critSec) {
  296.                 list.CopyTo(array, index);
  297.             }
  298.         }
  299.     }
  300. }

Developer Fusion