List is a generic, dynamic collection that allows you to store elements of a specific type and is widely used for its flexibility. List is part of the System.Collections.Generic namespace and is known for its ability to grow and shrink as elements are added or removed. It also provides fast access by index, making it easier to search and update elements.
Best Use Case:
Use List when you need a dynamic collection that allows for adding and removing elements easily, while also supporting quick access by index.
Ideal Scenarios:
- Variable-sized lists: Useful when the number of elements may grow or shrink over time.
- Indexed access: Ideal when you need to access elements directly by their index.
- Data manipulation and sorting: List provides methods for sorting and manipulating data, such as Sort, Find, Remove, and more.
Example Code:
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
numbers.Add(6);
numbers.Remove(2);
Console.WriteLine(numbers[2]); // Output: 4
}
}List<T>is a dynamic, indexed collection.- Supports adding, removing, and sorting elements.
- Use Case: When a flexible list with fast indexed access is needed.
2. IEnumerable
IEnumerable is an interface that defines a sequence of enumerable elements. Unlike List, IEnumerable does not allow for adding or removing elements and is limited to read-only operations. It’s commonly used to represent collections when the exact type of collection is not important.
Best Use Case:
Ideal for scenarios where you only need to iterate over a collection without modifying it. The IEnumerable interface works well with LINQ methods, making it ideal for querying and manipulating data.
Ideal Scenarios:
- Methods returning collections: Ideal for methods that return a collection without requiring a concrete collection type.
- Data Streams: Useful for situations where the collection is generated or loaded on-demand, such as reading lines from a text file.
- LINQ operations: Works well with LINQ, enabling queries like Where, Select, and OrderBy.
Example Code:
using System;
using System.Collections.Generic;
using System.Linq;
class Program
{
static void Main()
{
IEnumerable<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
foreach (var num in numbers)
{
Console.WriteLine(num);
}
}
}IEnumerable<T>allows iteration but not modification.- Commonly used with LINQ.
- Use Case: When read-only access to a collection is needed.
3. ICollection
The ICollection interface is a generic collection that adds more functionality to IEnumerable, allowing for count and manipulation operations, such as adding and removing elements. It’s an intermediate choice that provides flexibility without committing to a specific collection type.
Best Use Case:
ICollection is useful when you need a modifiable collection but don’t want to be restricted to a specific type, like List or HashSet.
Ideal Scenarios:
- Generic collections: A good choice for methods that need to manipulate collections without specifying implementation details.
- Counting and manipulating data: Ideal for situations where operations like adding, removing, and counting elements are necessary.
Example Code:
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
ICollection<string> names = new List<string> { "Alice", "Bob" };
names.Add("Charlie");
names.Remove("Bob");
Console.WriteLine(names.Count); // Output: 2
}
}ICollection<T>extendsIEnumerable<T>and supports modification.- Provides
Count,Add(),Remove(), but not indexed access. - Use Case: When modification is needed but indexed access is not.
4. IList
IList inherits from ICollection and IEnumerable, adding indexed access and more flexibility for list-specific operations. It is ideal when you need a collection that allows manipulation by index.
Best Use Case:
For scenarios where direct access to specific elements by index is needed, without requiring a specific implementation type.
Ideal Scenarios:
- Direct access to elements: When you need to access or modify elements at specific positions.
- Implementation flexibility: Allows switching the collection type in the future without modifying the interface.
Example Code:
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
IList<int> numbers = new List<int> { 10, 20, 30 };
numbers.Insert(1, 15);
Console.WriteLine(numbers[1]); // Output: 15
}
}IList<T>extendsICollection<T>, adding indexed access.- Allows insertion and modification at specific positions.
- Use Case: When indexed access and modification are both needed.
5. Array
The Array in C# is a fixed-size collection that stores elements of a specific type. It is highly efficient for accessing elements, but its size must be known in advance and cannot be changed.
Best Use Case:
Choose Array when you need a collection with a fixed size and fast indexed access.
Ideal Scenarios:
- Fixed-size collections: Useful when the number of elements is fixed and known in advance.
- Performance: Access to elements is fast, making it suitable for operations with a large number of data items and little need for flexibility.
- Immutable data: Ideal for storing static data.
Example Code:
using System;
class Program
{
static void Main()
{
int[] numbers = { 1, 2, 3, 4, 5 };
Console.WriteLine(numbers[2]); // Output: 3
}
}- Fixed-size, fast indexed access.
- Cannot grow or shrink dynamically.
- Use Case: When the size is known and performance is key.
6. Dictionary<TKey, TValue>
Dictionary<TKey, TValue> is a key-value pair collection where each key is unique. It is highly efficient for lookups and is commonly used when you need to associate data with specific keys.
Best Use Case:
Ideal for storing and accessing data by unique keys efficiently.
Ideal Scenarios:
- Key-value association: When each value needs to be associated with a unique key, such as a product catalog indexed by product code.
- Frequent lookups: When key-based lookups are frequent operations.
- Unique key data: Necessary when each element needs a unique identifier.
Example Code:
using System;
using System.Collections.Generic;
class Program
{
static void Main()
{
Dictionary<string, int> ages = new Dictionary<string, int>
{
{ "Alice", 25 },
{ "Bob", 30 }
};
Console.WriteLine(ages["Alice"]); // Output: 25
}
}- Stores key-value pairs.
- Keys are unique and enable fast lookups.
- Use Case: When fast key-based access is needed.
7. IQueryable
IQueryable is another key type in C#, especially useful in scenarios requiring complex and efficient queries on large datasets, such as database queries. IQueryable is an interface that extends IEnumerable to provide query capabilities that can be translated into an underlying query language like SQL. It is widely used with LINQ to SQL, LINQ to Entities (Entity Framework), and other data access libraries.
Best Use Case:
IQueryable is ideal for scenarios where the data source is large, like a database, and you need an efficient way to query and manipulate only the necessary data without loading the entire collection into memory.
Ideal Scenarios:
- Database queries: When used with ORMs like Entity Framework, Dapper, or LINQ to SQL, IQueryable allows the construction of queries that will be executed directly in the database.
- Dynamic filters and complex queries: In situations where the user can add filters, sorting, or pagination, as IQueryable allows the query to be composed over time.
- Reduced memory usage: Since IQueryable enables fetching only the required data, it avoids loading large amounts of data into memory unnecessarily.
Example Code:
using System;
using System.Linq;
using System.Collections.Generic;
class Program
{
static void Main()
{
List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
IQueryable<int> query = numbers.AsQueryable().Where(n => n > 2);
foreach (var num in query)
{
Console.WriteLine(num);
}
}
}IQueryable<T>extendsIEnumerable<T>, enabling database-friendly queries.- Used in Entity Framework / LINQ to SQL.
- Use Case: When querying large datasets efficiently.