Silverlight 5

WinRT

public abstract class Comparer`1<T>	public abstract class Comparer`1<T>
: IComparer, IComparer`1<T>	: IComparer, IComparer`1<T>
static public Comparer`1<T> Default { get; }	static public Comparer`1<> Default { get; }
public abstract virtual Int32 Compare(T x, T y);	public abstract virtual Int32 Compare(T x, T y);

public class Dictionary`2<TKey, TValue>	public class Dictionary`2<TKey, TValue>
: IDictionary`2<TKey, TValue>, ICollection`1<KeyValuePair`2<TKey, TValue>>, IEnumerable`1<KeyValuePair`2<TKey, TValue>>, IEnumerable, IDictionary, ICollection	: IDictionary`2<TKey, TValue>, ICollection`1<KeyValuePair`2<TKey, TValue>>, IEnumerable`1<KeyValuePair`2<TKey, TValue>>, IEnumerable, IDictionary, ICollection, IReadOnlyDictionary`2<TKey, TValue>, ISerializable, IDeserializationCallback
public IEqualityComparer`1<TKey> Comparer { get; }	public IEqualityComparer`1<TKey> Comparer { get; }
public virtual Int32 Count { get; }	public virtual Int32 Count { get; }
public virtual TValue Item { get; set; }	public virtual TValue Item { get; set; }
public KeyCollection<TKey, TValue> Keys { get; }	public KeyCollection<TKey, TValue> Keys { get; }
public ValueCollection<TKey, TValue> Values { get; }	public ValueCollection<TKey, TValue> Values { get; }
public virtual void Add(TKey key, TValue value);	public virtual void Add(TKey key, TValue value);
public virtual void Clear();	public virtual void Clear();
public virtual Boolean ContainsKey(TKey key);	public virtual Boolean ContainsKey(TKey key);
public Boolean ContainsValue(TValue value);	public Boolean ContainsValue(TValue value);
public Enumerator<TKey, TValue> GetEnumerator();	public Enumerator<TKey, TValue> GetEnumerator();
	public virtual void GetObjectData(SerializationInfo info, StreamingContext context);
	public virtual void OnDeserialization(Object sender);
public virtual Boolean Remove(TKey key);	public virtual Boolean Remove(TKey key);
public virtual Boolean TryGetValue(TKey key, out TValue& value);	public virtual Boolean TryGetValue(TKey key, out TValue& value);

sealed struct Dictionary`2+Enumerator<TKey, TValue>
: ValueType, IEnumerator`1<KeyValuePair`2<TKey, TValue>>, IDisposable, IEnumerator, IDictionaryEnumerator
public virtual KeyValuePair`2<TKey, TValue> Current { get; }
public virtual void Dispose();
public virtual Boolean MoveNext();

sealed struct KeyCollection+Enumerator<TKey, TValue>
: ValueType, IEnumerator`1<TKey>, IDisposable, IEnumerator
public virtual TKey Current { get; }
public virtual void Dispose();
public virtual Boolean MoveNext();

sealed struct ValueCollection+Enumerator<TKey, TValue>
: ValueType, IEnumerator`1<TValue>, IDisposable, IEnumerator
public virtual TValue Current { get; }
public virtual void Dispose();
public virtual Boolean MoveNext();

sealed struct List`1+Enumerator<T>
: ValueType, IEnumerator`1<T>, IDisposable, IEnumerator
public virtual T Current { get; }
public virtual void Dispose();
public virtual Boolean MoveNext();

sealed struct LinkedList`1+Enumerator<T>
: ValueType, IEnumerator`1<T>, IDisposable, IEnumerator
public virtual T Current { get; }
public virtual void Dispose();
public virtual Boolean MoveNext();

sealed struct Queue`1+Enumerator<T>
: ValueType, IEnumerator`1<T>, IDisposable, IEnumerator
public virtual T Current { get; }
public virtual void Dispose();
public virtual Boolean MoveNext();

sealed struct Stack`1+Enumerator<T>
: ValueType, IEnumerator`1<T>, IDisposable, IEnumerator
public virtual T Current { get; }
public virtual void Dispose();
public virtual Boolean MoveNext();

sealed struct HashSet`1+Enumerator<T>
: ValueType, IEnumerator`1<T>, IDisposable, IEnumerator
public virtual T Current { get; }
public virtual void Dispose();
public virtual Boolean MoveNext();

	sealed struct Dictionary`2<TKey, TValue>
	: ValueType, IEnumerator`1<KeyValuePair`2<TKey, TValue>>, IDisposable, IEnumerator, IDictionaryEnumerator
	public virtual KeyValuePair`2<TKey, TValue> Current { get; }
	public virtual void Dispose();
	public virtual Boolean MoveNext();

	sealed struct KeyCollection<TKey, TValue>
	: ValueType, IEnumerator`1<TKey>, IDisposable, IEnumerator
	public virtual TKey Current { get; }
	public virtual void Dispose();
	public virtual Boolean MoveNext();

	sealed struct ValueCollection<TKey, TValue>
	: ValueType, IEnumerator`1<TValue>, IDisposable, IEnumerator
	public virtual TValue Current { get; }
	public virtual void Dispose();
	public virtual Boolean MoveNext();

	sealed struct List`1<T>
	: ValueType, IEnumerator`1<T>, IDisposable, IEnumerator
	public virtual T Current { get; }
	public virtual void Dispose();
	public virtual Boolean MoveNext();

	sealed struct LinkedList`1<T>
	: ValueType, IEnumerator`1<T>, IDisposable, IEnumerator, ISerializable, IDeserializationCallback
	public virtual T Current { get; }
	public virtual void Dispose();
	public virtual Boolean MoveNext();

	sealed struct Queue`1<T>
	: ValueType, IEnumerator`1<T>, IDisposable, IEnumerator
	public virtual T Current { get; }
	public virtual void Dispose();
	public virtual Boolean MoveNext();

	sealed struct Stack`1<T>
	: ValueType, IEnumerator`1<T>, IDisposable, IEnumerator
	public virtual T Current { get; }
	public virtual void Dispose();
	public virtual Boolean MoveNext();

	sealed struct SortedDictionary`2<TKey, TValue>
	: ValueType, IEnumerator`1<KeyValuePair`2<TKey, TValue>>, IDisposable, IEnumerator, IDictionaryEnumerator
	public virtual KeyValuePair`2<TKey, TValue> Current { get; }
	public virtual void Dispose();
	public virtual Boolean MoveNext();

	sealed struct SortedSet`1<T>
	: ValueType, IEnumerator`1<T>, IDisposable, IEnumerator, ISerializable, IDeserializationCallback
	public virtual T Current { get; }
	public virtual void Dispose();
	public virtual Boolean MoveNext();

	sealed struct HashSet`1<T>
	: ValueType, IEnumerator`1<T>, IDisposable, IEnumerator
	public virtual T Current { get; }
	public virtual void Dispose();
	public virtual Boolean MoveNext();

public abstract class EqualityComparer`1<T>	public abstract class EqualityComparer`1<T>
: IEqualityComparer, IEqualityComparer`1<T>	: IEqualityComparer, IEqualityComparer`1<T>
static public EqualityComparer`1<T> Default { get; }	static public EqualityComparer`1<> Default { get; }
public abstract virtual Boolean Equals(T x, T y);	public abstract virtual Boolean Equals(T x, T y);
public abstract virtual Int32 GetHashCode(T obj);	public abstract virtual Int32 GetHashCode(T obj);

public class HashSet`1<T>	public class HashSet`1<T>
: ISet`1<T>, ICollection`1<T>, IEnumerable`1<T>, IEnumerable	: ISerializable, IDeserializationCallback, ISet`1<T>, ICollection`1<T>, IEnumerable`1<T>, IEnumerable
public IEqualityComparer`1<T> Comparer { get; }	public IEqualityComparer`1<T> Comparer { get; }
public virtual Int32 Count { get; }	public virtual Int32 Count { get; }
public virtual Boolean Add(T item);	public virtual Boolean Add(T item);
public virtual void Clear();	public virtual void Clear();
public virtual Boolean Contains(T item);	public virtual Boolean Contains(T item);
public virtual void CopyTo(T array, Int32 arrayIndex);	public virtual void CopyTo(T array, Int32 arrayIndex);
public void CopyTo(T array);	public void CopyTo(T array);
public void CopyTo(T array, Int32 arrayIndex, Int32 count);	public void CopyTo(T array, Int32 arrayIndex, Int32 count);
	static public IEqualityComparer`1<HashSet`1<>> CreateSetComparer();
public virtual void ExceptWith(IEnumerable`1<T> other);	public virtual void ExceptWith(IEnumerable`1<T> other);
public Enumerator<T> GetEnumerator();	public Enumerator<T> GetEnumerator();
	public virtual void GetObjectData(SerializationInfo info, StreamingContext context);
public virtual void IntersectWith(IEnumerable`1<T> other);	public virtual void IntersectWith(IEnumerable`1<T> other);
public virtual Boolean IsProperSubsetOf(IEnumerable`1<T> other);	public virtual Boolean IsProperSubsetOf(IEnumerable`1<T> other);
public virtual Boolean IsProperSupersetOf(IEnumerable`1<T> other);	public virtual Boolean IsProperSupersetOf(IEnumerable`1<T> other);
public virtual Boolean IsSubsetOf(IEnumerable`1<T> other);	public virtual Boolean IsSubsetOf(IEnumerable`1<T> other);
public virtual Boolean IsSupersetOf(IEnumerable`1<T> other);	public virtual Boolean IsSupersetOf(IEnumerable`1<T> other);
	public virtual void OnDeserialization(Object sender);
public virtual Boolean Overlaps(IEnumerable`1<T> other);	public virtual Boolean Overlaps(IEnumerable`1<T> other);
public virtual Boolean Remove(T item);	public virtual Boolean Remove(T item);
public Int32 RemoveWhere(Predicate`1<T> match);	public Int32 RemoveWhere(Predicate`1<T> match);
public virtual Boolean SetEquals(IEnumerable`1<T> other);	public virtual Boolean SetEquals(IEnumerable`1<T> other);
public virtual void SymmetricExceptWith(IEnumerable`1<T> other);	public virtual void SymmetricExceptWith(IEnumerable`1<T> other);
public void TrimExcess();	public void TrimExcess();
public virtual void UnionWith(IEnumerable`1<T> other);	public virtual void UnionWith(IEnumerable`1<T> other);

public abstract interface ICollection`1<T>	public abstract interface ICollection`1<T>
: IEnumerable`1<T>, IEnumerable	: IEnumerable`1<T>, IEnumerable
public abstract virtual Int32 Count { get; }	public abstract virtual Int32 Count { get; }
public abstract virtual Boolean IsReadOnly { get; }	public abstract virtual Boolean IsReadOnly { get; }
public abstract virtual void Add(T item);	public abstract virtual void Add(T item);
public abstract virtual void Clear();	public abstract virtual void Clear();
public abstract virtual Boolean Contains(T item);	public abstract virtual Boolean Contains(T item);
public abstract virtual void CopyTo(T array, Int32 arrayIndex);	public abstract virtual void CopyTo(T array, Int32 arrayIndex);
public abstract virtual Boolean Remove(T item);	public abstract virtual Boolean Remove(T item);

public abstract interface IComparer`1<T>	public abstract interface IComparer`1<T>
public abstract virtual Int32 Compare(T x, T y);	public abstract virtual Int32 Compare(T x, T y);

public abstract interface IDictionary`2<TKey, TValue>	public abstract interface IDictionary`2<TKey, TValue>
: ICollection`1<KeyValuePair`2<TKey, TValue>>, IEnumerable`1<KeyValuePair`2<TKey, TValue>>, IEnumerable	: ICollection`1<KeyValuePair`2<TKey, TValue>>, IEnumerable`1<KeyValuePair`2<TKey, TValue>>, IEnumerable
public abstract virtual TValue Item { get; set; }	public abstract virtual TValue Item { get; set; }
public abstract virtual ICollection`1<TKey> Keys { get; }	public abstract virtual ICollection`1<TKey> Keys { get; }
public abstract virtual ICollection`1<TValue> Values { get; }	public abstract virtual ICollection`1<TValue> Values { get; }
public abstract virtual void Add(TKey key, TValue value);	public abstract virtual void Add(TKey key, TValue value);
public abstract virtual Boolean ContainsKey(TKey key);	public abstract virtual Boolean ContainsKey(TKey key);
public abstract virtual Boolean Remove(TKey key);	public abstract virtual Boolean Remove(TKey key);
public abstract virtual Boolean TryGetValue(TKey key, out TValue& value);	public abstract virtual Boolean TryGetValue(TKey key, out TValue& value);

public abstract interface IEnumerable`1<T>	public abstract interface IEnumerable`1<T>
: IEnumerable	: IEnumerable
public abstract virtual IEnumerator`1<T> GetEnumerator();	public abstract virtual IEnumerator`1<T> GetEnumerator();

public abstract interface IEnumerator`1<T>	public abstract interface IEnumerator`1<T>
: IDisposable, IEnumerator	: IDisposable, IEnumerator
public abstract virtual T Current { get; }	public abstract virtual T Current { get; }

public abstract interface IEqualityComparer`1<T>	public abstract interface IEqualityComparer`1<T>
public abstract virtual Boolean Equals(T x, T y);	public abstract virtual Boolean Equals(T x, T y);
public abstract virtual Int32 GetHashCode(T obj);	public abstract virtual Int32 GetHashCode(T obj);

public abstract interface IList`1<T>	public abstract interface IList`1<T>
: ICollection`1<T>, IEnumerable`1<T>, IEnumerable	: ICollection`1<T>, IEnumerable`1<T>, IEnumerable
public abstract virtual T Item { get; set; }	public abstract virtual T Item { get; set; }
public abstract virtual Int32 IndexOf(T item);	public abstract virtual Int32 IndexOf(T item);
public abstract virtual void Insert(Int32 index, T item);	public abstract virtual void Insert(Int32 index, T item);
public abstract virtual void RemoveAt(Int32 index);	public abstract virtual void RemoveAt(Int32 index);

	public abstract interface IReadOnlyDictionary`2<TKey, TValue>
	: IEnumerable`1<KeyValuePair`2<TKey, TValue>>, IEnumerable
	public abstract virtual Int32 Count { get; }
	public abstract virtual TValue Item { get; }
	public abstract virtual IEnumerable`1<TKey> Keys { get; }
	public abstract virtual IEnumerable`1<TValue> Values { get; }
	public abstract virtual Boolean ContainsKey(TKey key);
	public abstract virtual Boolean TryGetValue(TKey key, out TValue& value);

	public abstract interface IReadOnlyList`1<T>
	: IEnumerable`1<T>, IEnumerable
	public abstract virtual Int32 Count { get; }
	public abstract virtual T Item { get; }

public abstract interface ISet`1<T>	public abstract interface ISet`1<T>
: ICollection`1<T>, IEnumerable`1<T>, IEnumerable	: ICollection`1<T>, IEnumerable`1<T>, IEnumerable
public abstract virtual Boolean Add(T item);	public abstract virtual Boolean Add(T item);
public abstract virtual void ExceptWith(IEnumerable`1<T> other);	public abstract virtual void ExceptWith(IEnumerable`1<T> other);
public abstract virtual void IntersectWith(IEnumerable`1<T> other);	public abstract virtual void IntersectWith(IEnumerable`1<T> other);
public abstract virtual Boolean IsProperSubsetOf(IEnumerable`1<T> other);	public abstract virtual Boolean IsProperSubsetOf(IEnumerable`1<T> other);
public abstract virtual Boolean IsProperSupersetOf(IEnumerable`1<T> other);	public abstract virtual Boolean IsProperSupersetOf(IEnumerable`1<T> other);
public abstract virtual Boolean IsSubsetOf(IEnumerable`1<T> other);	public abstract virtual Boolean IsSubsetOf(IEnumerable`1<T> other);
public abstract virtual Boolean IsSupersetOf(IEnumerable`1<T> other);	public abstract virtual Boolean IsSupersetOf(IEnumerable`1<T> other);
public abstract virtual Boolean Overlaps(IEnumerable`1<T> other);	public abstract virtual Boolean Overlaps(IEnumerable`1<T> other);
public abstract virtual Boolean SetEquals(IEnumerable`1<T> other);	public abstract virtual Boolean SetEquals(IEnumerable`1<T> other);
public abstract virtual void SymmetricExceptWith(IEnumerable`1<T> other);	public abstract virtual void SymmetricExceptWith(IEnumerable`1<T> other);
public abstract virtual void UnionWith(IEnumerable`1<T> other);	public abstract virtual void UnionWith(IEnumerable`1<T> other);

sealed class Dictionary`2+KeyCollection<TKey, TValue>
: ICollection`1<TKey>, IEnumerable`1<TKey>, IEnumerable, ICollection
public virtual Int32 Count { get; }
public virtual void CopyTo(TKey array, Int32 index);
public Enumerator<TKey, TValue> GetEnumerator();

	sealed class Dictionary`2<TKey, TValue>
	: ICollection`1<TKey>, IEnumerable`1<TKey>, IEnumerable, ICollection
	public virtual Int32 Count { get; }
	public virtual void CopyTo(TKey array, Int32 index);
	public Enumerator<TKey, TValue> GetEnumerator();

	sealed class SortedDictionary`2<TKey, TValue>
	: ICollection`1<TKey>, IEnumerable`1<TKey>, IEnumerable, ICollection
	public virtual Int32 Count { get; }
	public virtual void CopyTo(TKey array, Int32 index);
	public Enumerator<TKey, TValue> GetEnumerator();

public class KeyedByTypeCollection`1<TItem>	public class KeyedByTypeCollection`1<TItem>
: KeyedCollection`2<Type, TItem>, IList`1<TItem>, ICollection`1<TItem>, IEnumerable`1<TItem>, IEnumerable, IList, ICollection	: KeyedCollection`2<Type, TItem>, IList`1<TItem>, ICollection`1<TItem>, IEnumerable`1<TItem>, IEnumerable, IList, ICollection, IReadOnlyList`1<TItem>
public T Find();	public T Find();
public Collection`1<T> FindAll();	public Collection`1<T> FindAll();
	protected virtual Type GetKeyForItem(TItem item);
	protected virtual void InsertItem(Int32 index, TItem item);
public T Remove();	public T Remove();
public Collection`1<T> RemoveAll();	public Collection`1<T> RemoveAll();

public class KeyNotFoundException	public class KeyNotFoundException
: SystemException, _Exception	: SystemException, ISerializable, _Exception

public sealed struct KeyValuePair`2<TKey, TValue>	public sealed struct KeyValuePair`2<TKey, TValue>
: ValueType	: ValueType
public TKey Key { get; }	public TKey Key { get; }
public TValue Value { get; }	public TValue Value { get; }
public virtual String ToString();	public virtual String ToString();

public class LinkedList`1<T>	public class LinkedList`1<T>
: ICollection`1<T>, IEnumerable`1<T>, IEnumerable, ICollection	: ICollection`1<T>, IEnumerable`1<T>, IEnumerable, ICollection, ISerializable, IDeserializationCallback
public virtual Int32 Count { get; }	public virtual Int32 Count { get; }
public LinkedListNode`1<T> First { get; }	public LinkedListNode`1<T> First { get; }
public LinkedListNode`1<T> Last { get; }	public LinkedListNode`1<T> Last { get; }
public LinkedListNode`1<T> AddAfter(LinkedListNode`1<T> node, T value);	public LinkedListNode`1<T> AddAfter(LinkedListNode`1<T> node, T value);
public void AddAfter(LinkedListNode`1<T> node, LinkedListNode`1<T> newNode);	public void AddAfter(LinkedListNode`1<T> node, LinkedListNode`1<T> newNode);
public LinkedListNode`1<T> AddBefore(LinkedListNode`1<T> node, T value);	public LinkedListNode`1<T> AddBefore(LinkedListNode`1<T> node, T value);
public void AddBefore(LinkedListNode`1<T> node, LinkedListNode`1<T> newNode);	public void AddBefore(LinkedListNode`1<T> node, LinkedListNode`1<T> newNode);
public LinkedListNode`1<T> AddFirst(T value);	public LinkedListNode`1<T> AddFirst(T value);
public void AddFirst(LinkedListNode`1<T> node);	public void AddFirst(LinkedListNode`1<T> node);
public LinkedListNode`1<T> AddLast(T value);	public LinkedListNode`1<T> AddLast(T value);
public void AddLast(LinkedListNode`1<T> node);	public void AddLast(LinkedListNode`1<T> node);
public virtual void Clear();	public virtual void Clear();
public virtual Boolean Contains(T value);	public virtual Boolean Contains(T value);
public virtual void CopyTo(T array, Int32 index);	public virtual void CopyTo(T array, Int32 index);
public LinkedListNode`1<T> Find(T value);	public LinkedListNode`1<T> Find(T value);
public LinkedListNode`1<T> FindLast(T value);	public LinkedListNode`1<T> FindLast(T value);
public Enumerator<T> GetEnumerator();	public Enumerator<T> GetEnumerator();
	public virtual void GetObjectData(SerializationInfo info, StreamingContext context);
	public virtual void OnDeserialization(Object sender);
public virtual Boolean Remove(T value);	public virtual Boolean Remove(T value);
public void Remove(LinkedListNode`1<T> node);	public void Remove(LinkedListNode`1<T> node);
public void RemoveFirst();	public void RemoveFirst();
public void RemoveLast();	public void RemoveLast();

public sealed class LinkedListNode`1<T>	public sealed class LinkedListNode`1<T>
public LinkedList`1<T> List { get; }	public LinkedList`1<T> List { get; }
public LinkedListNode`1<T> Next { get; }	public LinkedListNode`1<> Next { get; }
public LinkedListNode`1<T> Previous { get; }	public LinkedListNode`1<> Previous { get; }
public T Value { get; set; }	public T Value { get; set; }

public class List`1<T>	public class List`1<T>
: IList`1<T>, ICollection`1<T>, IEnumerable`1<T>, IEnumerable, IList, ICollection	: IList`1<T>, ICollection`1<T>, IEnumerable`1<T>, IEnumerable, IList, ICollection, IReadOnlyList`1<T>
public Int32 Capacity { get; set; }	public Int32 Capacity { get; set; }
public virtual Int32 Count { get; }	public virtual Int32 Count { get; }
public virtual T Item { get; set; }	public virtual T Item { get; set; }
public virtual void Add(T item);	public virtual void Add(T item);
public void AddRange(IEnumerable`1<T> collection);	public void AddRange(IEnumerable`1<T> collection);
public ReadOnlyCollection`1<T> AsReadOnly();	public ReadOnlyCollection`1<T> AsReadOnly();
public Int32 BinarySearch(Int32 index, Int32 count, T item, IComparer`1<T> comparer);	public Int32 BinarySearch(Int32 index, Int32 count, T item, IComparer`1<T> comparer);
public Int32 BinarySearch(T item);	public Int32 BinarySearch(T item);
public Int32 BinarySearch(T item, IComparer`1<T> comparer);	public Int32 BinarySearch(T item, IComparer`1<T> comparer);
public virtual void Clear();	public virtual void Clear();
public virtual Boolean Contains(T item);	public virtual Boolean Contains(T item);
	public List`1<TOutput> ConvertAll(Converter`2<T, TOutput> converter);
public void CopyTo(T array);	public void CopyTo(T array);
public void CopyTo(Int32 index, T array, Int32 arrayIndex, Int32 count);	public void CopyTo(Int32 index, T array, Int32 arrayIndex, Int32 count);
public virtual void CopyTo(T array, Int32 arrayIndex);	public virtual void CopyTo(T array, Int32 arrayIndex);
	public Boolean Exists(Predicate`1<T> match);
	public T Find(Predicate`1<T> match);
	public List`1<> FindAll(Predicate`1<T> match);
	public Int32 FindIndex(Predicate`1<T> match);
	public Int32 FindIndex(Int32 startIndex, Predicate`1<T> match);
	public Int32 FindIndex(Int32 startIndex, Int32 count, Predicate`1<T> match);
	public T FindLast(Predicate`1<T> match);
	public Int32 FindLastIndex(Predicate`1<T> match);
	public Int32 FindLastIndex(Int32 startIndex, Predicate`1<T> match);
	public Int32 FindLastIndex(Int32 startIndex, Int32 count, Predicate`1<T> match);
public void ForEach(Action`1<T> action);	public void ForEach(Action`1<T> action);
public Enumerator<T> GetEnumerator();	public Enumerator<T> GetEnumerator();
public List`1<T> GetRange(Int32 index, Int32 count);	public List`1<> GetRange(Int32 index, Int32 count);
public virtual Int32 IndexOf(T item);	public virtual Int32 IndexOf(T item);
public Int32 IndexOf(T item, Int32 index);	public Int32 IndexOf(T item, Int32 index);
public Int32 IndexOf(T item, Int32 index, Int32 count);	public Int32 IndexOf(T item, Int32 index, Int32 count);
public virtual void Insert(Int32 index, T item);	public virtual void Insert(Int32 index, T item);
public void InsertRange(Int32 index, IEnumerable`1<T> collection);	public void InsertRange(Int32 index, IEnumerable`1<T> collection);
public Int32 LastIndexOf(T item);	public Int32 LastIndexOf(T item);
public Int32 LastIndexOf(T item, Int32 index);	public Int32 LastIndexOf(T item, Int32 index);
public Int32 LastIndexOf(T item, Int32 index, Int32 count);	public Int32 LastIndexOf(T item, Int32 index, Int32 count);
public virtual Boolean Remove(T item);	public virtual Boolean Remove(T item);
public Int32 RemoveAll(Predicate`1<T> match);	public Int32 RemoveAll(Predicate`1<T> match);
public virtual void RemoveAt(Int32 index);	public virtual void RemoveAt(Int32 index);
public void RemoveRange(Int32 index, Int32 count);	public void RemoveRange(Int32 index, Int32 count);
public void Reverse();	public void Reverse();
public void Reverse(Int32 index, Int32 count);	public void Reverse(Int32 index, Int32 count);
public void Sort();	public void Sort();
public void Sort(IComparer`1<T> comparer);	public void Sort(IComparer`1<T> comparer);
public void Sort(Int32 index, Int32 count, IComparer`1<T> comparer);	public void Sort(Int32 index, Int32 count, IComparer`1<T> comparer);
public void Sort(Comparison`1<T> comparison);	public void Sort(Comparison`1<T> comparison);
public T ToArray();	public T ToArray();
public void TrimExcess();	public void TrimExcess();

public class Queue`1<T>	public class Queue`1<T>
: IEnumerable`1<T>, IEnumerable, ICollection	: IEnumerable`1<T>, IEnumerable, ICollection
public virtual Int32 Count { get; }	public virtual Int32 Count { get; }
public void Clear();	public void Clear();
public Boolean Contains(T item);	public Boolean Contains(T item);
public void CopyTo(T array, Int32 arrayIndex);	public void CopyTo(T array, Int32 arrayIndex);
public T Dequeue();	public T Dequeue();
public void Enqueue(T item);	public void Enqueue(T item);
public Enumerator<T> GetEnumerator();	public Enumerator<T> GetEnumerator();
public T Peek();	public T Peek();
public T ToArray();	public T ToArray();
public void TrimExcess();	public void TrimExcess();

	public class SortedDictionary`2<TKey, TValue>
	: IDictionary`2<TKey, TValue>, ICollection`1<KeyValuePair`2<TKey, TValue>>, IEnumerable`1<KeyValuePair`2<TKey, TValue>>, IEnumerable, IDictionary, ICollection
	public IComparer`1<TKey> Comparer { get; }
	public virtual Int32 Count { get; }
	public virtual TValue Item { get; set; }
	public KeyCollection<TKey, TValue> Keys { get; }
	public ValueCollection<TKey, TValue> Values { get; }
	public virtual void Add(TKey key, TValue value);
	public virtual void Clear();
	public virtual Boolean ContainsKey(TKey key);
	public Boolean ContainsValue(TValue value);
	public virtual void CopyTo(KeyValuePair`2 array, Int32 index);
	public Enumerator<TKey, TValue> GetEnumerator();
	public virtual Boolean Remove(TKey key);
	public virtual Boolean TryGetValue(TKey key, out TValue& value);

	public class SortedList`2<TKey, TValue>
	: IDictionary`2<TKey, TValue>, ICollection`1<KeyValuePair`2<TKey, TValue>>, IEnumerable`1<KeyValuePair`2<TKey, TValue>>, IEnumerable, IDictionary, ICollection
	public Int32 Capacity { get; set; }
	public IComparer`1<TKey> Comparer { get; }
	public virtual Int32 Count { get; }
	public virtual TValue Item { get; set; }
	public IList`1<TKey> Keys { get; }
	public IList`1<TValue> Values { get; }
	public virtual void Add(TKey key, TValue value);
	public virtual void Clear();
	public virtual Boolean ContainsKey(TKey key);
	public Boolean ContainsValue(TValue value);
	public IEnumerator`1<KeyValuePair`2<TKey, TValue>> GetEnumerator();
	public Int32 IndexOfKey(TKey key);
	public Int32 IndexOfValue(TValue value);
	public virtual Boolean Remove(TKey key);
	public void RemoveAt(Int32 index);
	public void TrimExcess();
	public virtual Boolean TryGetValue(TKey key, out TValue& value);

	public class SortedSet`1<T>
	: ISet`1<T>, ICollection`1<T>, IEnumerable`1<T>, IEnumerable, ICollection, ISerializable, IDeserializationCallback
	public IComparer`1<T> Comparer { get; }
	public virtual Int32 Count { get; }
	public T Max { get; }
	public T Min { get; }
	public virtual Boolean Add(T item);
	public virtual void Clear();
	public virtual Boolean Contains(T item);
	public void CopyTo(T array);
	public virtual void CopyTo(T array, Int32 index);
	public void CopyTo(T array, Int32 index, Int32 count);
	static public IEqualityComparer`1<SortedSet`1<>> CreateSetComparer();
	static public IEqualityComparer`1<SortedSet`1<>> CreateSetComparer(IEqualityComparer`1<T> memberEqualityComparer);
	public virtual void ExceptWith(IEnumerable`1<T> other);
	public Enumerator<T> GetEnumerator();
	protected virtual void GetObjectData(SerializationInfo info, StreamingContext context);
	public virtual SortedSet`1<> GetViewBetween(T lowerValue, T upperValue);
	public virtual void IntersectWith(IEnumerable`1<T> other);
	public virtual Boolean IsProperSubsetOf(IEnumerable`1<T> other);
	public virtual Boolean IsProperSupersetOf(IEnumerable`1<T> other);
	public virtual Boolean IsSubsetOf(IEnumerable`1<T> other);
	public virtual Boolean IsSupersetOf(IEnumerable`1<T> other);
	protected virtual void OnDeserialization(Object sender);
	public virtual Boolean Overlaps(IEnumerable`1<T> other);
	public virtual Boolean Remove(T item);
	public Int32 RemoveWhere(Predicate`1<T> match);
	public IEnumerable`1<T> Reverse();
	public virtual Boolean SetEquals(IEnumerable`1<T> other);
	public virtual void SymmetricExceptWith(IEnumerable`1<T> other);
	public virtual void UnionWith(IEnumerable`1<T> other);

public class Stack`1<T>	public class Stack`1<T>
: IEnumerable`1<T>, IEnumerable, ICollection	: IEnumerable`1<T>, IEnumerable, ICollection
public virtual Int32 Count { get; }	public virtual Int32 Count { get; }
public void Clear();	public void Clear();
public Boolean Contains(T item);	public Boolean Contains(T item);
public void CopyTo(T array, Int32 arrayIndex);	public void CopyTo(T array, Int32 arrayIndex);
public Enumerator<T> GetEnumerator();	public Enumerator<T> GetEnumerator();
public T Peek();	public T Peek();
public T Pop();	public T Pop();
public void Push(T item);	public void Push(T item);
public T ToArray();	public T ToArray();
public void TrimExcess();	public void TrimExcess();

	public class SynchronizedCollection`1<T>
	: IList`1<T>, ICollection`1<T>, IEnumerable`1<T>, IEnumerable, IList, ICollection
	public virtual Int32 Count { get; }
	public virtual T Item { get; set; }
	protected List`1<T> Items { get; }
	public Object SyncRoot { get; }
	public virtual void Add(T item);
	public virtual void Clear();
	protected virtual void ClearItems();
	public virtual Boolean Contains(T item);
	public virtual void CopyTo(T array, Int32 index);
	public virtual IEnumerator`1<T> GetEnumerator();
	public virtual Int32 IndexOf(T item);
	public virtual void Insert(Int32 index, T item);
	protected virtual void InsertItem(Int32 index, T item);
	public virtual Boolean Remove(T item);
	public virtual void RemoveAt(Int32 index);
	protected virtual void RemoveItem(Int32 index);
	protected virtual void SetItem(Int32 index, T item);

	public abstract class SynchronizedKeyedCollection`2<K, T>
	: SynchronizedCollection`1<T>, IList`1<T>, ICollection`1<T>, IEnumerable`1<T>, IEnumerable, IList, ICollection
	protected IDictionary`2<K, T> Dictionary { get; }
	public T Item { get; }
	protected void ChangeItemKey(T item, K newKey);
	protected virtual void ClearItems();
	public Boolean Contains(K key);
	protected abstract virtual K GetKeyForItem(T item);
	protected virtual void InsertItem(Int32 index, T item);
	public Boolean Remove(K key);
	protected virtual void RemoveItem(Int32 index);
	protected virtual void SetItem(Int32 index, T item);

public class SynchronizedReadOnlyCollection`1<T>	public class SynchronizedReadOnlyCollection`1<T>
: IList`1<T>, ICollection`1<T>, IEnumerable`1<T>, IEnumerable, IList, ICollection	: IList`1<T>, ICollection`1<T>, IEnumerable`1<T>, IEnumerable, IList, ICollection
public virtual Int32 Count { get; }	public virtual Int32 Count { get; }
public T Item { get; }	public T Item { get; }
	protected IList`1<T> Items { get; }
public virtual Boolean Contains(T value);	public virtual Boolean Contains(T value);
public virtual void CopyTo(T array, Int32 index);	public virtual void CopyTo(T array, Int32 index);
public virtual IEnumerator`1<T> GetEnumerator();	public virtual IEnumerator`1<T> GetEnumerator();
public virtual Int32 IndexOf(T value);	public virtual Int32 IndexOf(T value);

sealed class Dictionary`2+ValueCollection<TKey, TValue>
: ICollection`1<TValue>, IEnumerable`1<TValue>, IEnumerable, ICollection
public virtual Int32 Count { get; }
public virtual void CopyTo(TValue array, Int32 index);
public Enumerator<TKey, TValue> GetEnumerator();

	sealed class Dictionary`2<TKey, TValue>
	: ICollection`1<TValue>, IEnumerable`1<TValue>, IEnumerable, ICollection
	public virtual Int32 Count { get; }
	public virtual void CopyTo(TValue array, Int32 index);
	public Enumerator<TKey, TValue> GetEnumerator();

	sealed class SortedDictionary`2<TKey, TValue>
	: ICollection`1<TValue>, IEnumerable`1<TValue>, IEnumerable, ICollection
	public virtual Int32 Count { get; }
	public virtual void CopyTo(TValue array, Int32 index);
	public Enumerator<TKey, TValue> GetEnumerator();