Are C# non-generic collections obsolete?

[Monica Shiralkar]

C# has both generic and non generic collections? Are the non generic collections of C# obselette.

Thanks

[Campbell Ritchie]

Why would anybody want to use a non‑generic collection if generic collections are available?

[Stephan van Hulst]

You mean "obsolete". That's a tough question to answer. Many APIs still work with the non-generic versions, and some have made a partial transition in that they check that a collection implements the generic version before they attempt call the non-generic methods.

I recommend that when you write methods that accept or return collections, they only accept or return the generic versions. When you write a collection type, implement BOTH the non-generic and generic versions, but give explicit method implementations for the non-generic version, so they can not be called directly on your type. You can easily do this by extending either the System.Collections.ObjectModel.Collection<T> or the System.Collections.ObjectModel.ReadOnlyCollection<T> class, which confusingly implement both the IList and the IList<T> interfaces. If you don't want your collection to be indexable, you can also just implement ICollection and ICollection<T>. Here's an example of a Heap implementation:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

internal sealed class MinHeap<T> : ICollection, ICollection<T>
{
	internal MinHeap(IComparer<T> comparer, IEnumerable<T> items)
	{
		Comparer = comparer ?? throw new ArgumentNullException(nameof(comparer));
		Items = new List<T>(items);

		for (var index = LastIndex; index.HasValue; index = index?.Previous)
		{
			BubbleDown(index.Value);
		}
	}

	internal MinHeap(IComparer<T> comparer)
		: this(comparer, Enumerable.Empty<T>())
	{
	}

	internal MinHeap(IEnumerable<T> items)
		: this(Comparer<T>.Default, items)
	{
	}

	internal MinHeap()
		: this(Comparer<T>.Default, Enumerable.Empty<T>())
	{
	}

	private IComparer<T> Comparer { get; }

	private List<T> Items { get; }

	public bool IsReadOnly => false;

	public bool IsSynchronized => false;

	public object SyncRoot => ((IList)Items).SyncRoot;

	public int Count => Items.Count;

	internal bool IsEmpty => Count == 0;

	private Index? LastIndex => IsEmpty ? default(Index?) : Count - 1;

	private bool ContainsIndex(Index index) => index < Items.Count;

	private Index? Search(T item, Index subtreeIndex)
	{
		if (!ContainsIndex(subtreeIndex))
		{
			return null;
		}

		var subtreeItem = Items[subtreeIndex];

		if (Equals(item, subtreeItem))
		{
			return subtreeIndex;
		}

		if (Comparer.Compare(item, subtreeItem) < 0)
		{
			return null;
		}

		return Search(item, subtreeIndex.Left) ?? Search(item, subtreeIndex.Right);
	}

	public bool Contains(T item)
	{
		return Search(item, Index.Root).HasValue;
	}

	private Index BubbleUp(Index index)
	{
		if (index.IsRoot)
		{
			return index;
		}

		var parentIndex = index.Parent.Value;

		var item = Items[index];
		var parentItem = Items[parentIndex];

		if (Comparer.Compare(item, parentItem) >= 0)
		{
			return index;
		}

		Items[parentIndex] = item;
		Items[index] = parentItem;
		return BubbleUp(parentIndex);
	}

	private Index BubbleDown(Index index)
	{
		var leftIndex = index.Left;
		if (!ContainsIndex(leftIndex))
		{
			return index;
		}

		var leastChild = Items[leftIndex];
		var leastChildIndex = leftIndex;

		var rightIndex = index.Right;
		if (ContainsIndex(rightIndex))
		{
			var rightItem = Items[rightIndex];
			if (Comparer.Compare(rightItem, leastChild) < 0)
			{
				leastChild = rightItem;
				leastChildIndex = rightIndex;
			}
		}

		var item = Items[index];

		if (Comparer.Compare(item, leastChild) <= 0)
		{
			return index;
		}

		Items[leastChildIndex] = item;
		Items[index] = leastChild;
		return BubbleDown(leastChildIndex);
	}

	public void Add(T item)
	{
		Items.Add(item);
		BubbleUp(LastIndex.Value);
	}

	private T RemoveAt(Index index)
	{
		if (!ContainsIndex(index))
		{
			throw new IndexOutOfRangeException();
		}

		var lastIndex = LastIndex.Value;

		var removedItem = Items[index];
		Items[index] = Items[lastIndex];
		Items.RemoveAt(lastIndex);

		BubbleDown(index);

		return removedItem;
	}

	internal T RemoveFirst()
	{
		if (IsEmpty)
		{
			throw new InvalidOperationException("The heap is empty.");
		}

		return RemoveAt(Index.Root);
	}

	public bool Remove(T item)
	{
		var index = Search(item, Index.Root);

		if (!index.HasValue)
		{
			return false;
		}

		RemoveAt(index.Value);
		return true;
	}

	public void Clear()
	{
		Items.Clear();
	}

	public IEnumerator<T> GetEnumerator()
	{
		return Items.GetEnumerator();
	}

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

	public void CopyTo(T[] array, int arrayIndex)
	{
		Items.CopyTo(array, arrayIndex);
	}

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

	private struct Index : IEquatable<Index>
	{
		private Index(int value)
		{
			Value = value;
		}

		private int Value { get; }

		internal static Index Root => 0;

		internal bool IsRoot => Value == 0;

		internal Index? Previous => IsRoot ? default(Index?) : Value - 1;

		internal Index Next => Value + 1;

		internal Index? Parent => IsRoot ? default(Index?) : (Value - 1) / 2;

		internal Index Left => Value * 2 + 1;

		internal Index Right => Left.Next;

		public static implicit operator Index(int value) => new Index(value);

		public static implicit operator int(Index index) => index.Value;

		public static bool operator ==(Index first, Index second) => Equals(first, second);

		public static bool operator !=(Index first, Index second) => !Equals(first, second);

		public bool Equals(Index other) => Value == other.Value;

		public override bool Equals(object obj) => obj is Index other && Equals(other);

		public override int GetHashCode() => Value;

		public override string ToString() => Value.ToString();
	}
}

[Monica Shiralkar]

Thanks.. If new generic collections have been introduced and the non generic ones are still there because the transition is still doing on then is it not the same case as saying that non generic collections are obselette now. Is there any difference.

[Stephan van Hulst]

I suppose you could put it that way.

[Monica Shiralkar]

Thanks.  I think like vector had gone obselette in Java.

[Bill Crim]

Parts of the .NET framework code still use the non-generic versions. This is only for legacy reasons, or special use cases. Lots of code uses the older collections as a base class, then adds behavior on top of it.

You should always use the Generic versions. The generic versions are better, they also benefit from new extension methods that target the newer interfaces. IEnumerable<T>(the main hook into LINQ) vs IEnumerable(You use .Cast<T>() to enable to use LINQ). Don't use the older Collections unless there is a specific API that requires them for legacy reasons.  

[Monica Shiralkar]

Thanks

[Ishan Shah]

c# have tow a different type of collection (1) generic  (2) non-generic
In non-generic collections, each element can represent a value of a different type.
The collection size is not fixed. Items from the collection can be added or removed at runtime.
then c# is a non-generic collection.

[Stephan van Hulst]

Ishan Shah wrote:In non-generic collections, each element can represent a value of a different type.

This is true for generic collections as well, as you can add elements that are a subtype of the generic type argument of the collection.

The collection size is not fixed. Items from the collection can be added or removed at runtime.

Not true in general. There are both fixed size and unmodifiable collections.