StringCollection.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / CompMod / System / Collections / Specialized / StringCollection.cs / 1 / StringCollection.cs
                        

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

namespace System.Collections.Specialized { 
 
    using System.Diagnostics;
    using System.Collections; 

    /// 
    ///    Represents a collection of strings.
    ///  
    [
        Serializable, 
    ] 
    public class StringCollection : IList {
        private ArrayList data = new ArrayList(); 

        /// 
        /// Represents the entry at the specified index of the .
        ///  
        public string this[int index] {
            get { 
                return ((string)data[index]); 
            }
            set { 
                data[index] = value;
            }
        }
 
        /// 
        ///    Gets the number of strings in the 
        ///     . 
        /// 
        public int Count { 
            get {
                return data.Count;
            }
        } 

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

 
        /// 
        ///    Adds a string with the specified value to the 
        ///     . 
        /// 
        public int Add(string value) { 
            return data.Add(value);
        }

        ///  
        /// Copies the elements of a string array to the end of the .
        ///  
        public void AddRange(string[] value) { 
            if (value == null) {
                throw new ArgumentNullException("value"); 
            }
            data.AddRange(value);
        }
 
        /// 
        ///    Removes all the strings from the 
        ///     . 
        /// 
        public void Clear() { 
            data.Clear();
        }

        ///  
        ///    Gets a value indicating whether the
        ///     contains a string with the specified 
        ///       value. 
        /// 
        public bool Contains(string value) { 
            return data.Contains(value);
        }

        ///  
        /// Copies the  values to a one-dimensional  instance at the
        ///    specified index. 
        ///  
        public void CopyTo(string[] array, int index) {
            data.CopyTo(array, index); 
        }

        /// 
        ///    Returns an enumerator that can iterate through 
        ///       the  .
        ///  
        public StringEnumerator GetEnumerator() { 
            return new StringEnumerator(this);
        } 

        /// 
        ///    Returns the index of the first occurrence of a string in
        ///       the  . 
        /// 
        public int IndexOf(string value) { 
            return data.IndexOf(value); 
        }
 
        /// 
        /// Inserts a string into the  at the specified
        ///    index.
        ///  
        public void Insert(int index, string value) {
            data.Insert(index, value); 
        } 

        ///  
        /// Gets a value indicating whether the  is read-only.
        /// 
        public bool IsReadOnly {
            get { 
                return false;
            } 
        } 

        ///  
        ///    Gets a value indicating whether access to the
        ///    
        ///    is synchronized (thread-safe).
        ///  
        public bool IsSynchronized {
            get { 
                return false; 
            }
        } 

        /// 
        ///     Removes a specific string from the
        ///     . 
        /// 
        public void Remove(string value) { 
            data.Remove(value); 
        }
 
        /// 
        /// Removes the string at the specified index of the .
        /// 
        public void RemoveAt(int index) { 
            data.RemoveAt(index);
        } 
 
        /// 
        /// Gets an object that can be used to synchronize access to the . 
        /// 
        public object SyncRoot {
            get {
                return data.SyncRoot; 
            }
        } 
 
        object IList.this[int index] {
            get { 
                return this[index];
            }
            set {
                this[index] = (string)value; 
            }
        } 
 
        int IList.Add(object value) {
            return Add((string)value); 
        }

        bool IList.Contains(object value) {
            return Contains((string) value); 
        }
 
 
        int IList.IndexOf(object value) {
            return IndexOf((string)value); 
        }

        void IList.Insert(int index, object value) {
            Insert(index, (string)value); 
        }
 
        void IList.Remove(object value) { 
            Remove((string)value);
        } 

        void ICollection.CopyTo(Array array, int index) {
            data.CopyTo(array, index);
        } 

        IEnumerator IEnumerable.GetEnumerator() { 
            return data.GetEnumerator(); 
        }
    } 

    /// 
    ///    [To be supplied.]
    ///  
    public class StringEnumerator {
        private System.Collections.IEnumerator baseEnumerator; 
        private System.Collections.IEnumerable temp; 

        internal StringEnumerator(StringCollection mappings) { 
            this.temp = (IEnumerable)(mappings);
            this.baseEnumerator = temp.GetEnumerator();
        }
 
        /// 
        ///    [To be supplied.] 
        ///  
        public string Current {
            get { 
                return (string)(baseEnumerator.Current);
            }
        }
 
        /// 
        ///    [To be supplied.] 
        ///  
        public bool MoveNext() {
            return baseEnumerator.MoveNext(); 
        }
        /// 
        ///    [To be supplied.]
        ///  
        public void Reset() {
            baseEnumerator.Reset(); 
        } 

    } 
}

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