Data Manipulation Abstractions

Hey guys, nice meeting you again. Today, we will be looking at Data Manipulation Abstraction used in .NET. This simply means data collections interfaces which include the interfaces you are already familiar with like ICollection, IEnumerable, IQueryable, and IList. They represent different levels of abstraction for handling collections of data. I am sure you understand the term interface and abstraction correctly. For revision sake, let us their definition.

What is an Interface?:

An interface is a contract in programming that defines a set of methods, properties, or events that a class or struct must implement, without providing any implementation details. It enables loose coupling and polymorphism.

What is Abstraction?:

Abstraction is a design principle that focuses on hiding the implementation details of a system or object while exposing only the essential features and functionality to the user. It simplifies complex systems by modeling relevant aspects

I think we are now good to touch on the data manipulation abstractions identified above. Their key differences and features are as follow:

1. IEnumerable Definition: The base interface for all non-generic and generic collections that allow iteration over a sequence of items. Key Features: Provides an enumerator to iterate through a collection using a foreach loop. Implements a single method: GetEnumerator. Suitable for forward-only, read-only access to a collection. Deferred execution when used with LINQ queries.

   Use Case: When you need simple iteration over a collection.

   Example: List or Array implementing IEnumerable.

2. ICollection Definition: Extends IEnumerable and defines size, enumeration, and thread-safety methods for collections. Key Features: Adds properties like Count and methods like Add, Remove, and Contains. Represents a collection that can be modified (in most implementations). Does not provide indexing.

   Use Case: When you need a modifiable collection but do not require indexed access. Example: HashSet, List.

3. IList Definition: Extends ICollection and represents collections with indexed access. Key Features: Supports zero-based indexing through the this[int index] indexer. Allows adding, removing, and updating items at specific indexes. Suitable for random access. Use Case: When you need a collection with indexed, random access to elements. Example: List, Array.

4. IQueryable Definition: Extends IEnumerable and provides functionality for querying data from a data source. Key Features: Allows LINQ queries to be translated into a data source's native query language (e.g., SQL for Entity Framework). Supports deferred execution of queries. Suitable for querying large datasets or databases. Executes queries remotely on the data source, not in memory.

   Use Case: When querying remote data sources like databases.

   Example: DbSet in Entity Framework Core implements IQueryable.

The Tabular Summary:

Each interface serves a specific purpose, and choosing the right one depends on the requirements of the operation you need to perform.

Access Mode: There are 2 key access mode referenced in this context which I will try to explain a little. They direct indexing and deferred execution.

Direct Indexing

• Definition: Direct indexing refers to the ability to access elements in a collection using their position (index) in constant time (O(1)). The collection must support zero-based indexing.

• Key Characteristics:

  • Provides quick and easy access to any element in the collection.

  • Uses an indexer (e.g., this[index] in .NET) to retrieve or set elements.

  • Supported by collections that implement interfaces like IList, Array, or Dictionary (for keys).

• Example:

IList<int> numbers = new List<int> { 10, 20, 30 };
int secondNumber = numbers[1]; // Accesses the second element directly.

• Use Case:

  • When you need random access to elements.

  • When performance for retrieval by position is critical.

---

Deferred Execution

• Definition: Deferred execution means that the evaluation of a query or the execution of an operation is delayed until its results are actually accessed.

• Key Characteristics:

  • Lazy Evaluation: The query is not executed when it is defined but when it is iterated or accessed (e.g., in a foreach loop).

  • Common in LINQ queries in .NET.

  • Allows for improved performance and reduced memory usage by avoiding unnecessary computations.

• Example:

IEnumerable<int> numbers = Enumerable.Range(1, 10);
var query = numbers.Where(x => x % 2 == 0); // Query definition (deferred).

foreach (var num in query)
{
    Console.WriteLine(num); // Execution happens here.
}

• Use Case:

  • When working with large datasets and you want to minimize processing overhead.

  • When querying remote data sources like databases to avoid loading unnecessary data.

---

Comparison of Direct Indexing and Deferred Execution

Thanks for reading. Kindly share your observations and do well to comment as well.