TraceListeners.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / CompMod / System / Diagnostics / TraceListeners.cs / 1305376 / TraceListeners.cs

                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

/* 
 */ 
namespace System.Diagnostics {
    using System; 
    using System.Collections;
    using Microsoft.Win32;

    ///  
    /// Provides a thread-safe list of . A thread-safe list is synchronized.
    ///  
    public class TraceListenerCollection : IList { 
        ArrayList list;
 
        internal TraceListenerCollection() {
            list = new ArrayList(1);
        }
 
        /// 
        /// Gets or sets the  at 
        ///    the specified index. 
        /// 
        public TraceListener this[int i] { 
            get {
                return (TraceListener)list[i];
            }
 
            set {
                InitializeListener(value); 
                list[i] = value; 
            }
        } 

        /// 
        /// Gets the first  in the list with the specified name.
        ///  
        public TraceListener this[string name] {
            get { 
                foreach (TraceListener listener in this) { 
                    if (listener.Name == name)
                        return listener; 
                }
                return null;
            }
        } 

        ///  
        ///     
        ///       Gets the number of listeners in the list.
        ///     
        /// 
        public int Count {
            get {
                return list.Count; 
            }
        } 
 
        /// 
        /// Adds a  to the list. 
        /// 
        public int Add(TraceListener listener) {
            InitializeListener(listener);
 
            lock (TraceInternal.critSec) {
                return list.Add(listener); 
            } 
        }
 
        /// 
        ///    [To be supplied.]
        /// 
        public void AddRange(TraceListener[] value) { 
            if (value == null) {
                throw new ArgumentNullException("value"); 
            } 
            for (int i = 0; ((i) < (value.Length)); i = ((i) + (1))) {
                this.Add(value[i]); 
            }
        }

        ///  
        ///    [To be supplied.]
        ///  
        public void AddRange(TraceListenerCollection value) { 
            if (value == null) {
                throw new ArgumentNullException("value"); 
            }
            int currentCount = value.Count;
            for (int i = 0; i < currentCount; i = ((i) + (1))) {
                this.Add(value[i]); 
            }
        } 
 
        /// 
        ///     
        ///       Clears all the listeners from the
        ///       list.
        ///    
        ///  
        public void Clear() {
            list = new ArrayList(); 
        } 

        ///  
        ///    Checks whether the list contains the specified
        ///       listener.
        /// 
        public bool Contains(TraceListener listener) { 
            return ((IList)this).Contains(listener);
        } 
 
        /// 
        /// Copies a section of the current  list to the specified array at the specified 
        ///    index.
        /// 
        public void CopyTo(TraceListener[] listeners, int index) {
            ((ICollection)this).CopyTo((Array) listeners, index); 
        }
 
        ///  
        ///    
        ///       Gets an enumerator for this list. 
        ///    
        /// 
        public IEnumerator GetEnumerator() {
            return list.GetEnumerator(); 
        }
 
        internal void InitializeListener(TraceListener listener) { 
            if (listener == null)
                throw new ArgumentNullException("listener"); 

            listener.IndentSize = TraceInternal.IndentSize;
            listener.IndentLevel = TraceInternal.IndentLevel;
        } 

        ///  
        ///    Gets the index of the specified listener. 
        /// 
        public int IndexOf(TraceListener listener) { 
            return ((IList)this).IndexOf(listener);
        }

        ///  
        ///    Inserts the listener at the specified index.
        ///  
        public void Insert(int index, TraceListener listener) { 
            InitializeListener(listener);
            lock (TraceInternal.critSec) { 
                list.Insert(index, listener);
            }
        }
 
        /// 
        ///     
        ///       Removes the specified instance of the  class from the list. 
        ///    
        ///  
        public void Remove(TraceListener listener) {
            ((IList)this).Remove(listener);
        }
 
        /// 
        ///    Removes the first listener in the list that has the 
        ///       specified name. 
        /// 
        public void Remove(string name) { 
            TraceListener listener = this[name];
            if (listener != null)
                ((IList)this).Remove(listener);
        } 

        ///  
        /// Removes the  at the specified index. 
        /// 
        public void RemoveAt(int index) { 
            lock (TraceInternal.critSec) {
                list.RemoveAt(index);
            }
        } 

       ///  
       object IList.this[int index] { 
            get {
                return list[index]; 
            }

            set {
                TraceListener listener = value as TraceListener; 
                if (listener == null)
                    throw new ArgumentException(SR.GetString(SR.MustAddListener),"value"); 
                InitializeListener(listener); 
                list[index] = listener;
 
            }
        }

        ///  
        bool IList.IsReadOnly {
            get { 
                return false; 
            }
        } 

        /// 
        bool IList.IsFixedSize {
            get { 
                return false;
            } 
        } 

        ///  
        int IList.Add(object value) {
            TraceListener listener = value as TraceListener;
            if (listener == null)
                throw new ArgumentException(SR.GetString(SR.MustAddListener),"value"); 

            InitializeListener(listener); 
 
            lock (TraceInternal.critSec) {
                return list.Add(value); 
            }
        }

        ///  
        bool IList.Contains(object value) {
            return list.Contains(value); 
        } 

        ///  
        int IList.IndexOf(object value) {
            return list.IndexOf(value);
        }
 
        /// 
        void IList.Insert(int index, object value) { 
            TraceListener listener = value as TraceListener; 
            if (listener == null)
                throw new ArgumentException(SR.GetString(SR.MustAddListener),"value"); 

            InitializeListener(listener);

            lock (TraceInternal.critSec) { 
                list.Insert(index, value);
            } 
        } 

        ///  
        void IList.Remove(object value) {
            lock (TraceInternal.critSec) {
                list.Remove(value);
            } 
        }
 
        ///  
        object ICollection.SyncRoot {
            get { 
                return this;
            }
        }
 
        /// 
        bool ICollection.IsSynchronized { 
            get { 
                return true;
            } 
        }

        /// 
        void ICollection.CopyTo(Array array, int index) { 
            lock (TraceInternal.critSec) {
                list.CopyTo(array, index); 
            } 
        }
    } 
}

// 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