diff options
Diffstat (limited to 'src/mscorlib/shared/System/Collections')
23 files changed, 814 insertions, 0 deletions
diff --git a/src/mscorlib/shared/System/Collections/DictionaryEntry.cs b/src/mscorlib/shared/System/Collections/DictionaryEntry.cs new file mode 100644 index 0000000000..290306d006 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/DictionaryEntry.cs @@ -0,0 +1,58 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.ComponentModel; + +namespace System.Collections +{ + // A DictionaryEntry holds a key and a value from a dictionary. + // It is returned by IDictionaryEnumerator::GetEntry(). + [Serializable] + public struct DictionaryEntry + { + private Object _key; + private Object _value; + + // Constructs a new DictionaryEnumerator by setting the Key + // and Value fields appropriately. + public DictionaryEntry(Object key, Object value) + { + _key = key; + _value = value; + } + + public Object Key + { + get + { + return _key; + } + + set + { + _key = value; + } + } + + public Object Value + { + get + { + return _value; + } + + set + { + _value = value; + } + } + + [EditorBrowsable(EditorBrowsableState.Never)] + public void Deconstruct(out object key, out object value) + { + key = Key; + value = Value; + } + } +} diff --git a/src/mscorlib/shared/System/Collections/Generic/ICollection.cs b/src/mscorlib/shared/System/Collections/Generic/ICollection.cs new file mode 100644 index 0000000000..52852aa1fb --- /dev/null +++ b/src/mscorlib/shared/System/Collections/Generic/ICollection.cs @@ -0,0 +1,35 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Runtime.CompilerServices; +using System.Diagnostics.Contracts; + +namespace System.Collections.Generic +{ + // Base interface for all collections, defining enumerators, size, and + // synchronization methods. + public interface ICollection<T> : IEnumerable<T> + { + // Number of items in the collections. + int Count { get; } + + bool IsReadOnly { get; } + + void Add(T item); + + void Clear(); + + bool Contains(T item); + + // CopyTo copies a collection into an Array, starting at a particular + // index into the array. + // + void CopyTo(T[] array, int arrayIndex); + + //void CopyTo(int sourceIndex, T[] destinationArray, int destinationIndex, int count); + + bool Remove(T item); + } +} diff --git a/src/mscorlib/shared/System/Collections/Generic/IComparer.cs b/src/mscorlib/shared/System/Collections/Generic/IComparer.cs new file mode 100644 index 0000000000..713d499cc8 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/Generic/IComparer.cs @@ -0,0 +1,20 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; + +namespace System.Collections.Generic +{ + // The generic IComparer interface implements a method that compares + // two objects. It is used in conjunction with the Sort and + // BinarySearch methods on the Array, List, and SortedList classes. + public interface IComparer<in T> + { + // Compares two objects. An implementation of this method must return a + // value less than zero if x is less than y, zero if x is equal to y, or a + // value greater than zero if x is greater than y. + // + int Compare(T x, T y); + } +} diff --git a/src/mscorlib/shared/System/Collections/Generic/IDictionary.cs b/src/mscorlib/shared/System/Collections/Generic/IDictionary.cs new file mode 100644 index 0000000000..a73a2f55bd --- /dev/null +++ b/src/mscorlib/shared/System/Collections/Generic/IDictionary.cs @@ -0,0 +1,51 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Diagnostics.Contracts; + +namespace System.Collections.Generic +{ + // An IDictionary is a possibly unordered set of key-value pairs. + // Keys can be any non-null object. Values can be any object. + // You can look up a value in an IDictionary via the default indexed + // property, Items. + public interface IDictionary<TKey, TValue> : ICollection<KeyValuePair<TKey, TValue>> + { + // Interfaces are not serializable + // The Item property provides methods to read and edit entries + // in the Dictionary. + TValue this[TKey key] + { + get; + set; + } + + // Returns a collections of the keys in this dictionary. + ICollection<TKey> Keys + { + get; + } + + // Returns a collections of the values in this dictionary. + ICollection<TValue> Values + { + get; + } + + // Returns whether this dictionary contains a particular key. + // + bool ContainsKey(TKey key); + + // Adds a key-value pair to the dictionary. + // + void Add(TKey key, TValue value); + + // Removes a particular key from the dictionary. + // + bool Remove(TKey key); + + bool TryGetValue(TKey key, out TValue value); + } +} diff --git a/src/mscorlib/shared/System/Collections/Generic/IEnumerable.cs b/src/mscorlib/shared/System/Collections/Generic/IEnumerable.cs new file mode 100644 index 0000000000..84264d5cf0 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/Generic/IEnumerable.cs @@ -0,0 +1,21 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Diagnostics.Contracts; + +namespace System.Collections.Generic +{ + // Implement this interface if you need to support foreach semantics. + public interface IEnumerable<out T> : IEnumerable + { + // Returns an IEnumerator for this enumerable Object. The enumerator provides + // a simple way to access all the contents of a collection. + /// <include file='doc\IEnumerable.uex' path='docs/doc[@for="IEnumerable.GetEnumerator"]/*' /> + new IEnumerator<T> GetEnumerator(); + } +} diff --git a/src/mscorlib/shared/System/Collections/Generic/IEnumerator.cs b/src/mscorlib/shared/System/Collections/Generic/IEnumerator.cs new file mode 100644 index 0000000000..6360576974 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/Generic/IEnumerator.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Runtime.InteropServices; + +namespace System.Collections.Generic +{ + // Base interface for all generic enumerators, providing a simple approach + // to iterating over a collection. + public interface IEnumerator<out T> : IDisposable, IEnumerator + { + // Returns the current element of the enumeration. The returned value is + // undefined before the first call to MoveNext and following a + // call to MoveNext that returned false. Multiple calls to + // GetCurrent with no intervening calls to MoveNext + // will return the same object. + // + /// <include file='doc\IEnumerator.uex' path='docs/doc[@for="IEnumerator.Current"]/*' /> + new T Current + { + get; + } + } +} diff --git a/src/mscorlib/shared/System/Collections/Generic/IEqualityComparer.cs b/src/mscorlib/shared/System/Collections/Generic/IEqualityComparer.cs new file mode 100644 index 0000000000..543bdb5fce --- /dev/null +++ b/src/mscorlib/shared/System/Collections/Generic/IEqualityComparer.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; + +namespace System.Collections.Generic +{ + // The generic IEqualityComparer interface implements methods to if check two objects are equal + // and generate Hashcode for an object. + // It is use in Dictionary class. + public interface IEqualityComparer<in T> + { + bool Equals(T x, T y); + int GetHashCode(T obj); + } +} + diff --git a/src/mscorlib/shared/System/Collections/Generic/IList.cs b/src/mscorlib/shared/System/Collections/Generic/IList.cs new file mode 100644 index 0000000000..43d6659da9 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/Generic/IList.cs @@ -0,0 +1,37 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Collections; +using System.Runtime.CompilerServices; +using System.Diagnostics.Contracts; + +namespace System.Collections.Generic +{ + // An IList is an ordered collection of objects. The exact ordering + // is up to the implementation of the list, ranging from a sorted + // order to insertion order. + public interface IList<T> : ICollection<T> + { + // The Item property provides methods to read and edit entries in the List. + T this[int index] + { + get; + set; + } + + // Returns the index of a particular item, if it is in the list. + // Returns -1 if the item isn't in the list. + int IndexOf(T item); + + // Inserts value into the list at position index. + // index must be non-negative and less than or equal to the + // number of elements in the list. If index equals the number + // of items in the list, then value is appended to the end. + void Insert(int index, T item); + + // Removes the item at position index. + void RemoveAt(int index); + } +} diff --git a/src/mscorlib/shared/System/Collections/Generic/IReadOnlyCollection.cs b/src/mscorlib/shared/System/Collections/Generic/IReadOnlyCollection.cs new file mode 100644 index 0000000000..09ee89f035 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/Generic/IReadOnlyCollection.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Diagnostics.Contracts; +using System.Runtime.CompilerServices; + +namespace System.Collections.Generic +{ + // Provides a read-only, covariant view of a generic list. + public interface IReadOnlyCollection<out T> : IEnumerable<T> + { + int Count { get; } + } +} diff --git a/src/mscorlib/shared/System/Collections/Generic/IReadOnlyDictionary.cs b/src/mscorlib/shared/System/Collections/Generic/IReadOnlyDictionary.cs new file mode 100644 index 0000000000..169e2958bb --- /dev/null +++ b/src/mscorlib/shared/System/Collections/Generic/IReadOnlyDictionary.cs @@ -0,0 +1,20 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Diagnostics.Contracts; + +namespace System.Collections.Generic +{ + // Provides a read-only view of a generic dictionary. + public interface IReadOnlyDictionary<TKey, TValue> : IReadOnlyCollection<KeyValuePair<TKey, TValue>> + { + bool ContainsKey(TKey key); + bool TryGetValue(TKey key, out TValue value); + + TValue this[TKey key] { get; } + IEnumerable<TKey> Keys { get; } + IEnumerable<TValue> Values { get; } + } +} diff --git a/src/mscorlib/shared/System/Collections/Generic/IReadOnlyList.cs b/src/mscorlib/shared/System/Collections/Generic/IReadOnlyList.cs new file mode 100644 index 0000000000..00b5be65ff --- /dev/null +++ b/src/mscorlib/shared/System/Collections/Generic/IReadOnlyList.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Diagnostics.Contracts; +using System.Runtime.CompilerServices; + +namespace System.Collections.Generic +{ + // Provides a read-only, covariant view of a generic list. + public interface IReadOnlyList<out T> : IReadOnlyCollection<T> + { + T this[int index] { get; } + } +} diff --git a/src/mscorlib/shared/System/Collections/Generic/KeyNotFoundException.cs b/src/mscorlib/shared/System/Collections/Generic/KeyNotFoundException.cs new file mode 100644 index 0000000000..1fca7732ae --- /dev/null +++ b/src/mscorlib/shared/System/Collections/Generic/KeyNotFoundException.cs @@ -0,0 +1,33 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Runtime.Serialization; + +namespace System.Collections.Generic +{ + [Serializable] + public class KeyNotFoundException : SystemException + { + public KeyNotFoundException() + : base(SR.Arg_KeyNotFound) + { + HResult = __HResults.COR_E_KEYNOTFOUND; + } + + public KeyNotFoundException(String message) + : base(message) + { + HResult = __HResults.COR_E_KEYNOTFOUND; + } + + public KeyNotFoundException(String message, Exception innerException) + : base(message, innerException) + { + HResult = __HResults.COR_E_KEYNOTFOUND; + } + + protected KeyNotFoundException(SerializationInfo info, StreamingContext context) : base(info, context) { } + } +} diff --git a/src/mscorlib/shared/System/Collections/Generic/KeyValuePair.cs b/src/mscorlib/shared/System/Collections/Generic/KeyValuePair.cs new file mode 100644 index 0000000000..fc51af25f8 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/Generic/KeyValuePair.cs @@ -0,0 +1,82 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System.ComponentModel; +using System.Text; + +namespace System.Collections.Generic +{ + // Provides the Create factory method for KeyValuePair<TKey, TValue>. + public static class KeyValuePair + { + // Creates a new KeyValuePair<TKey, TValue> from the given values. + public static KeyValuePair<TKey, TValue> Create<TKey, TValue>(TKey key, TValue value) + { + return new KeyValuePair<TKey, TValue>(key, value); + } + + /// <summary> + /// Used by KeyValuePair.ToString to reduce generic code + /// </summary> + internal static string PairToString(object key, object value) + { + StringBuilder s = StringBuilderCache.Acquire(); + s.Append('['); + + if (key != null) + { + s.Append(key); + } + + s.Append(", "); + + if (value != null) + { + s.Append(value); + } + + s.Append(']'); + + return StringBuilderCache.GetStringAndRelease(s); + } + } + + // A KeyValuePair holds a key and a value from a dictionary. + // It is used by the IEnumerable<T> implementation for both IDictionary<TKey, TValue> + // and IReadOnlyDictionary<TKey, TValue>. + [Serializable] + public struct KeyValuePair<TKey, TValue> + { + private TKey key; // DO NOT change the field name, it's required for compatibility with desktop .NET as it appears in serialization payload. + private TValue value; // DO NOT change the field name, it's required for compatibility with desktop .NET as it appears in serialization payload. + + public KeyValuePair(TKey key, TValue value) + { + this.key = key; + this.value = value; + } + + public TKey Key + { + get { return key; } + } + + public TValue Value + { + get { return value; } + } + + public override string ToString() + { + return KeyValuePair.PairToString(Key, Value); + } + + [EditorBrowsable(EditorBrowsableState.Never)] + public void Deconstruct(out TKey key, out TValue value) + { + key = Key; + value = Value; + } + } +} diff --git a/src/mscorlib/shared/System/Collections/ICollection.cs b/src/mscorlib/shared/System/Collections/ICollection.cs new file mode 100644 index 0000000000..80ea092363 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/ICollection.cs @@ -0,0 +1,70 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Diagnostics.Contracts; + +namespace System.Collections +{ + // Base interface for all collections, defining enumerators, size, and + // synchronization methods. + public interface ICollection : IEnumerable + { + // Interfaces are not serialable + // CopyTo copies a collection into an Array, starting at a particular + // index into the array. + // + void CopyTo(Array array, int index); + + // Number of items in the collections. + int Count + { get; } + + + // SyncRoot will return an Object to use for synchronization + // (thread safety). You can use this object in your code to take a + // lock on the collection, even if this collection is a wrapper around + // another collection. The intent is to tunnel through to a real + // implementation of a collection, and use one of the internal objects + // found in that code. + // + // In the absense of a static Synchronized method on a collection, + // the expected usage for SyncRoot would look like this: + // + // ICollection col = ... + // lock (col.SyncRoot) { + // // Some operation on the collection, which is now thread safe. + // // This may include multiple operations. + // } + // + // + // The system-provided collections have a static method called + // Synchronized which will create a thread-safe wrapper around the + // collection. All access to the collection that you want to be + // thread-safe should go through that wrapper collection. However, if + // you need to do multiple calls on that collection (such as retrieving + // two items, or checking the count then doing something), you should + // NOT use our thread-safe wrapper since it only takes a lock for the + // duration of a single method call. Instead, use Monitor.Enter/Exit + // or your language's equivalent to the C# lock keyword as mentioned + // above. + // + // For collections with no publically available underlying store, the + // expected implementation is to simply return the this pointer. Note + // that the this pointer may not be sufficient for collections that + // wrap other collections; those should return the underlying + // collection's SyncRoot property. + Object SyncRoot + { get; } + + // Is this collection synchronized (i.e., thread-safe)? If you want a + // thread-safe collection, you can use SyncRoot as an object to + // synchronize your collection with. If you're using one of the + // collections in System.Collections, you could call the static + // Synchronized method to get a thread-safe wrapper around the + // underlying collection. + bool IsSynchronized + { get; } + } +} diff --git a/src/mscorlib/shared/System/Collections/IComparer.cs b/src/mscorlib/shared/System/Collections/IComparer.cs new file mode 100644 index 0000000000..cef91c3ffa --- /dev/null +++ b/src/mscorlib/shared/System/Collections/IComparer.cs @@ -0,0 +1,22 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; + +namespace System.Collections +{ + // The IComparer interface implements a method that compares two objects. It is + // used in conjunction with the Sort and BinarySearch methods on + // the Array and List classes. + // + // Interfaces are not serializable + public interface IComparer + { + // Compares two objects. An implementation of this method must return a + // value less than zero if x is less than y, zero if x is equal to y, or a + // value greater than zero if x is greater than y. + // + int Compare(Object x, Object y); + } +} diff --git a/src/mscorlib/shared/System/Collections/IDictionary.cs b/src/mscorlib/shared/System/Collections/IDictionary.cs new file mode 100644 index 0000000000..8bc7fcf125 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/IDictionary.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Diagnostics.Contracts; + +namespace System.Collections +{ + // An IDictionary is a possibly unordered set of key-value pairs. + // Keys can be any non-null object. Values can be any object. + // You can look up a value in an IDictionary via the default indexed + // property, Items. + public interface IDictionary : ICollection + { + // Interfaces are not serializable + // The Item property provides methods to read and edit entries + // in the Dictionary. + Object this[Object key] + { + get; + set; + } + + // Returns a collections of the keys in this dictionary. + ICollection Keys + { + get; + } + + // Returns a collections of the values in this dictionary. + ICollection Values + { + get; + } + + // Returns whether this dictionary contains a particular key. + // + bool Contains(Object key); + + // Adds a key-value pair to the dictionary. + // + void Add(Object key, Object value); + + // Removes all pairs from the dictionary. + void Clear(); + + bool IsReadOnly + { get; } + + bool IsFixedSize + { get; } + + // Returns an IDictionaryEnumerator for this dictionary. + new IDictionaryEnumerator GetEnumerator(); + + // Removes a particular key from the dictionary. + // + void Remove(Object key); + } +} diff --git a/src/mscorlib/shared/System/Collections/IDictionaryEnumerator.cs b/src/mscorlib/shared/System/Collections/IDictionaryEnumerator.cs new file mode 100644 index 0000000000..451cf68976 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/IDictionaryEnumerator.cs @@ -0,0 +1,68 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace System.Collections +{ + // This interface represents an enumerator that allows sequential access to the + // elements of a dictionary. Upon creation, an enumerator is conceptually + // positioned before the first element of the enumeration. The first call to the + // MoveNext method brings the first element of the enumeration into view, + // and each successive call to MoveNext brings the next element into + // view until MoveNext returns false, indicating that there are no more + // elements to enumerate. Following each call to MoveNext, the + // Key and Value methods are used to obtain the key and + // value of the element currently in view. The values returned by calls to + // Key and Value are undefined before the first call to + // MoveNext and following a call to MoveNext that returned false. + // Enumerators are typically used in while loops of the form + // + // IDictionaryEnumerator e = ...; + // while (e.MoveNext()) { + // Object key = e.Key; + // Object value = e.Value; + // ... + // } + // + // The IDictionaryEnumerator interface extends the IEnumerator + // inerface and can thus be used as a regular enumerator. The Current + // method of an IDictionaryEnumerator returns a DictionaryEntry containing + // the current key and value pair. However, the GetEntry method will + // return the same DictionaryEntry and avoids boxing the DictionaryEntry (boxing + // is somewhat expensive). + // + public interface IDictionaryEnumerator : IEnumerator + { + // Returns the key of the current element of the enumeration. The returned + // value is undefined before the first call to GetNext and following + // a call to GetNext that returned false. Multiple calls to + // GetKey with no intervening calls to GetNext will return + // the same object. + // + Object Key + { + get; + } + + // Returns the value of the current element of the enumeration. The + // returned value is undefined before the first call to GetNext and + // following a call to GetNext that returned false. Multiple calls + // to GetValue with no intervening calls to GetNext will + // return the same object. + // + Object Value + { + get; + } + + // GetBlock will copy dictionary values into the given Array. It will either + // fill up the array, or if there aren't enough elements, it will + // copy as much as possible into the Array. The number of elements + // copied is returned. + // + DictionaryEntry Entry + { + get; + } + } +} diff --git a/src/mscorlib/shared/System/Collections/IEnumerable.cs b/src/mscorlib/shared/System/Collections/IEnumerable.cs new file mode 100644 index 0000000000..91aec62423 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/IEnumerable.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Diagnostics.Contracts; +using System.Runtime.InteropServices; + +namespace System.Collections +{ + public interface IEnumerable + { + // Returns an IEnumerator for this enumerable Object. The enumerator provides + // a simple way to access all the contents of a collection. + [Pure] + IEnumerator GetEnumerator(); + } +} diff --git a/src/mscorlib/shared/System/Collections/IEnumerator.cs b/src/mscorlib/shared/System/Collections/IEnumerator.cs new file mode 100644 index 0000000000..2c2c2e4a97 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/IEnumerator.cs @@ -0,0 +1,41 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Runtime.InteropServices; + +namespace System.Collections +{ + // Base interface for all enumerators, providing a simple approach + // to iterating over a collection. + public interface IEnumerator + { + // Advances the enumerator to the next element of the enumeration and + // returns a boolean indicating whether an element is available. Upon + // creation, an enumerator is conceptually positioned before the first + // element of the enumeration, and the first call to MoveNext + // brings the first element of the enumeration into view. + // + bool MoveNext(); + + // Returns the current element of the enumeration. The returned value is + // undefined before the first call to MoveNext and following a + // call to MoveNext that returned false. Multiple calls to + // GetCurrent with no intervening calls to MoveNext + // will return the same object. + // + Object Current + { + get; + } + + // Resets the enumerator to the beginning of the enumeration, starting over. + // The preferred behavior for Reset is to return the exact same enumeration. + // This means if you modify the underlying collection then call Reset, your + // IEnumerator will be invalid, just as it would have been if you had called + // MoveNext or Current. + // + void Reset(); + } +} diff --git a/src/mscorlib/shared/System/Collections/IEqualityComparer.cs b/src/mscorlib/shared/System/Collections/IEqualityComparer.cs new file mode 100644 index 0000000000..35513f577d --- /dev/null +++ b/src/mscorlib/shared/System/Collections/IEqualityComparer.cs @@ -0,0 +1,16 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; + +namespace System.Collections +{ + // An IEqualityComparer is a mechanism to consume custom performant comparison infrastructure + // that can be consumed by some of the common collections. + public interface IEqualityComparer + { + bool Equals(Object x, Object y); + int GetHashCode(Object obj); + } +} diff --git a/src/mscorlib/shared/System/Collections/IList.cs b/src/mscorlib/shared/System/Collections/IList.cs new file mode 100644 index 0000000000..bb2e221cc1 --- /dev/null +++ b/src/mscorlib/shared/System/Collections/IList.cs @@ -0,0 +1,60 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; +using System.Diagnostics.Contracts; + +namespace System.Collections +{ + // An IList is an ordered collection of objects. The exact ordering + // is up to the implementation of the list, ranging from a sorted + // order to insertion order. + public interface IList : ICollection + { + // The Item property provides methods to read and edit entries in the List. + Object this[int index] + { + get; + set; + } + + // Adds an item to the list. The exact position in the list is + // implementation-dependent, so while ArrayList may always insert + // in the last available location, a SortedList most likely would not. + // The return value is the position the new element was inserted in. + int Add(Object value); + + // Returns whether the list contains a particular item. + bool Contains(Object value); + + // Removes all items from the list. + void Clear(); + + bool IsReadOnly + { get; } + + + bool IsFixedSize + { + get; + } + + + // Returns the index of a particular item, if it is in the list. + // Returns -1 if the item isn't in the list. + int IndexOf(Object value); + + // Inserts value into the list at position index. + // index must be non-negative and less than or equal to the + // number of elements in the list. If index equals the number + // of items in the list, then value is appended to the end. + void Insert(int index, Object value); + + // Removes an item from the list. + void Remove(Object value); + + // Removes the item at position index. + void RemoveAt(int index); + } +} diff --git a/src/mscorlib/shared/System/Collections/IStructuralComparable.cs b/src/mscorlib/shared/System/Collections/IStructuralComparable.cs new file mode 100644 index 0000000000..a5e4834b9b --- /dev/null +++ b/src/mscorlib/shared/System/Collections/IStructuralComparable.cs @@ -0,0 +1,13 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +using System; + +namespace System.Collections +{ + public interface IStructuralComparable + { + Int32 CompareTo(Object other, IComparer comparer); + } +} diff --git a/src/mscorlib/shared/System/Collections/IStructuralEquatable.cs b/src/mscorlib/shared/System/Collections/IStructuralEquatable.cs new file mode 100644 index 0000000000..4e61d5e75f --- /dev/null +++ b/src/mscorlib/shared/System/Collections/IStructuralEquatable.cs @@ -0,0 +1,12 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +// See the LICENSE file in the project root for more information. + +namespace System.Collections +{ + public interface IStructuralEquatable + { + Boolean Equals(Object other, IEqualityComparer comparer); + int GetHashCode(IEqualityComparer comparer); + } +} |