ICollection Interface in C#

The ICollection interface in C# is a fundamental component of the .NET Framework's collections hierarchy. It provides the base functionality for all non-generic collections, which include methods to add, remove, and manage items in a collection. This article explores how to implement and utilize the ICollection interface effectively in various programming scenarios.

Understanding ICollection in C#

ICollection is part of the System.Collections namespace and serves as a crucial building block for collection classes like ArrayList, Queue, and Stack. It defines size, enumerators, and synchronization methods for collections, providing a consistent way to manage groups of objects.

Key Members of ICollection

The ICollection interface includes properties and methods that facilitate basic collection operations:

• Count: Gets the number of elements contained in the collection.
• IsSynchronized: Gets a value indicating whether access to the collection is synchronized (thread-safe).
• SyncRoot: Gets an object that can be used to synchronize access to the collection.
• CopyTo(Array, Int32): Copies the elements of the ICollection to an Array, starting at a particular Array index.

Implementing ICollection

To implement the ICollection interface, a class must implement all its properties and methods. Here’s a simple example of a class implementing ICollection:

public class SimpleCollection : ICollection
{
    private ArrayList items = new ArrayList();

    public int Count => items.Count;

    public bool IsSynchronized => false;

    public object SyncRoot => this;

    public void CopyTo(Array array, int index)
    {
        items.CopyTo(array, index);
    }

    public IEnumerator GetEnumerator()
    {
        return items.GetEnumerator();
    }

    public void Add(object value)
    {
        items.Add(value);
    }

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

    public bool Contains(object value)
    {
        return items.Contains(value);
    }

    public void Remove(object value)
    {
        items.Remove(value);
    }
}

Usage of ICollection

Implementing ICollection allows for the creation of flexible collections that can interact with other .NET collection types. Here’s how you can use the SimpleCollection class:

var myCollection = new SimpleCollection();
myCollection.Add("Hello");
myCollection.Add("World");

object[] content = new object[myCollection.Count];
myCollection.CopyTo(content, 0);

foreach (var item in content)
{
    Console.WriteLine(item);
}

Benefits of Using ICollection

Utilizing ICollection provides several benefits:

• Flexibility: Classes that implement ICollection can be integrated with other parts of the .NET Framework that utilize collections.
• Consistency: Adhering to the ICollection interface ensures that all collection classes provide a standard set of functionalities.
• Control: Custom collection classes can provide specialized behavior tailored to specific needs while maintaining a standard interface.

In summary, the ICollection interface is essential for developers who need to create collection classes that integrate seamlessly with other collections in .NET. By understanding and implementing ICollection, developers can ensure their custom collections are both robust and versatile.