Silverlight 5

WinRT

	public class BlockingCollection`1<T>
	: IEnumerable`1<T>, IEnumerable, ICollection, IDisposable
	public Int32 BoundedCapacity { get; }
	public virtual Int32 Count { get; }
	public Boolean IsAddingCompleted { get; }
	public Boolean IsCompleted { get; }
	public void Add(T item);
	public void Add(T item, CancellationToken cancellationToken);
	static public Int32 AddToAny(BlockingCollection`1 collections, T item);
	static public Int32 AddToAny(BlockingCollection`1 collections, T item, CancellationToken cancellationToken);
	public void CompleteAdding();
	public void CopyTo(T array, Int32 index);
	public virtual void Dispose();
	protected virtual void Dispose(Boolean disposing);
	public IEnumerable`1<T> GetConsumingEnumerable();
	public IEnumerable`1<T> GetConsumingEnumerable(CancellationToken cancellationToken);
	public T Take();
	public T Take(CancellationToken cancellationToken);
	static public Int32 TakeFromAny(BlockingCollection`1 collections, out T& item);
	static public Int32 TakeFromAny(BlockingCollection`1 collections, out T& item, CancellationToken cancellationToken);
	public T ToArray();
	public Boolean TryAdd(T item);
	public Boolean TryAdd(T item, TimeSpan timeout);
	public Boolean TryAdd(T item, Int32 millisecondsTimeout);
	public Boolean TryAdd(T item, Int32 millisecondsTimeout, CancellationToken cancellationToken);
	static public Int32 TryAddToAny(BlockingCollection`1 collections, T item);
	static public Int32 TryAddToAny(BlockingCollection`1 collections, T item, TimeSpan timeout);
	static public Int32 TryAddToAny(BlockingCollection`1 collections, T item, Int32 millisecondsTimeout);
	static public Int32 TryAddToAny(BlockingCollection`1 collections, T item, Int32 millisecondsTimeout, CancellationToken cancellationToken);
	public Boolean TryTake(out T& item);
	public Boolean TryTake(out T& item, TimeSpan timeout);
	public Boolean TryTake(out T& item, Int32 millisecondsTimeout);
	public Boolean TryTake(out T& item, Int32 millisecondsTimeout, CancellationToken cancellationToken);
	static public Int32 TryTakeFromAny(BlockingCollection`1 collections, out T& item);
	static public Int32 TryTakeFromAny(BlockingCollection`1 collections, out T& item, TimeSpan timeout);
	static public Int32 TryTakeFromAny(BlockingCollection`1 collections, out T& item, Int32 millisecondsTimeout);
	static public Int32 TryTakeFromAny(BlockingCollection`1 collections, out T& item, Int32 millisecondsTimeout, CancellationToken cancellationToken);

	public class ConcurrentBag`1<T>
	: IProducerConsumerCollection`1<T>, IEnumerable`1<T>, IEnumerable, ICollection
	public virtual Int32 Count { get; }
	public Boolean IsEmpty { get; }
	public void Add(T item);
	public virtual void CopyTo(T array, Int32 index);
	public virtual IEnumerator`1<T> GetEnumerator();
	public virtual T ToArray();
	public Boolean TryPeek(out T& result);
	public virtual Boolean TryTake(out T& result);

	public class ConcurrentDictionary`2<TKey, TValue>
	: IDictionary`2<TKey, TValue>, ICollection`1<KeyValuePair`2<TKey, TValue>>, IEnumerable`1<KeyValuePair`2<TKey, TValue>>, IEnumerable, IDictionary, ICollection
	public virtual Int32 Count { get; }
	public Boolean IsEmpty { get; }
	public virtual TValue Item { get; set; }
	public virtual ICollection`1<TKey> Keys { get; }
	public virtual ICollection`1<TValue> Values { get; }
	public TValue AddOrUpdate(TKey key, Func`2<TKey, TValue> addValueFactory, Func`3<TKey, TValue, TValue> updateValueFactory);
	public TValue AddOrUpdate(TKey key, TValue addValue, Func`3<TKey, TValue, TValue> updateValueFactory);
	public virtual void Clear();
	public virtual Boolean ContainsKey(TKey key);
	public virtual IEnumerator`1<KeyValuePair`2<TKey, TValue>> GetEnumerator();
	public TValue GetOrAdd(TKey key, Func`2<TKey, TValue> valueFactory);
	public TValue GetOrAdd(TKey key, TValue value);
	public KeyValuePair`2 ToArray();
	public Boolean TryAdd(TKey key, TValue value);
	public virtual Boolean TryGetValue(TKey key, out TValue& value);
	public Boolean TryRemove(TKey key, out TValue& value);
	public Boolean TryUpdate(TKey key, TValue newValue, TValue comparisonValue);

	public class ConcurrentQueue`1<T>
	: IProducerConsumerCollection`1<T>, IEnumerable`1<T>, IEnumerable, ICollection
	public virtual Int32 Count { get; }
	public Boolean IsEmpty { get; }
	public virtual void CopyTo(T array, Int32 index);
	public void Enqueue(T item);
	public virtual IEnumerator`1<T> GetEnumerator();
	public virtual T ToArray();
	public Boolean TryDequeue(out T& result);
	public Boolean TryPeek(out T& result);

	public class ConcurrentStack`1<T>
	: IProducerConsumerCollection`1<T>, IEnumerable`1<T>, IEnumerable, ICollection
	public virtual Int32 Count { get; }
	public Boolean IsEmpty { get; }
	public void Clear();
	public virtual void CopyTo(T array, Int32 index);
	public virtual IEnumerator`1<T> GetEnumerator();
	public void Push(T item);
	public void PushRange(T items);
	public void PushRange(T items, Int32 startIndex, Int32 count);
	public virtual T ToArray();
	public Boolean TryPeek(out T& result);
	public Boolean TryPop(out T& result);
	public Int32 TryPopRange(T items);
	public Int32 TryPopRange(T items, Int32 startIndex, Int32 count);

	public sealed enum EnumerablePartitionerOptions
	: IComparable, IFormattable, IConvertible
	{ None, NoBuffering }

	public abstract interface IProducerConsumerCollection`1<T>
	: IEnumerable`1<T>, IEnumerable, ICollection
	public abstract virtual void CopyTo(T array, Int32 index);
	public abstract virtual T ToArray();
	public abstract virtual Boolean TryAdd(T item);
	public abstract virtual Boolean TryTake(out T& item);

	public abstract class OrderablePartitioner`1<TSource>
	: Partitioner`1<TSource>
	public Boolean KeysNormalized { get; set; }
	public Boolean KeysOrderedAcrossPartitions { get; set; }
	public Boolean KeysOrderedInEachPartition { get; set; }
	public virtual IEnumerable`1<TSource> GetDynamicPartitions();
	public virtual IEnumerable`1<KeyValuePair`2<Int64, TSource>> GetOrderableDynamicPartitions();
	public abstract virtual IList`1<IEnumerator`1<KeyValuePair`2<Int64, TSource>>> GetOrderablePartitions(Int32 partitionCount);
	public virtual IList`1<IEnumerator`1<TSource>> GetPartitions(Int32 partitionCount);

	public abstract sealed class Partitioner
	static public OrderablePartitioner`1<TSource> Create(IList`1<TSource> list, Boolean loadBalance);
	static public OrderablePartitioner`1<TSource> Create(TSource array, Boolean loadBalance);
	static public OrderablePartitioner`1<TSource> Create(IEnumerable`1<TSource> source);
	static public OrderablePartitioner`1<TSource> Create(IEnumerable`1<TSource> source, EnumerablePartitionerOptions partitionerOptions);
	static public OrderablePartitioner`1<Tuple`2<Int64, Int64>> Create(Int64 fromInclusive, Int64 toExclusive);
	static public OrderablePartitioner`1<Tuple`2<Int64, Int64>> Create(Int64 fromInclusive, Int64 toExclusive, Int64 rangeSize);
	static public OrderablePartitioner`1<Tuple`2<Int32, Int32>> Create(Int32 fromInclusive, Int32 toExclusive);
	static public OrderablePartitioner`1<Tuple`2<Int32, Int32>> Create(Int32 fromInclusive, Int32 toExclusive, Int32 rangeSize);

	public abstract class Partitioner`1<TSource>
	public virtual Boolean SupportsDynamicPartitions { get; }
	public virtual IEnumerable`1<TSource> GetDynamicPartitions();
	public abstract virtual IList`1<IEnumerator`1<TSource>> GetPartitions(Int32 partitionCount);