Indexer declaration in C Sharp (C#) - Deep Dive

Overview - Indexer declaration

What is it?

An indexer in C# allows an object to be accessed like an array using square brackets []. It lets you define how to get or set values using an index, without exposing the internal data structure directly. This makes objects behave like collections or arrays in a simple and intuitive way. Indexers are declared inside classes or structs with a special syntax.

Why it matters

Without indexers, accessing elements inside objects would require calling methods explicitly, which can be verbose and less readable. Indexers make code cleaner and easier to understand by allowing natural array-like access to complex objects. This improves developer productivity and code maintainability, especially when working with collections or custom data containers.

Where it fits

Before learning indexers, you should understand classes, properties, and arrays in C#. After mastering indexers, you can explore advanced collection types, operator overloading, and custom data structures.

Mental Model

Core Idea

An indexer lets an object act like an array by defining how to get or set values using an index inside square brackets.

Think of it like...

Think of an indexer like a hotel receptionist who lets you access any room by giving the room number. You don’t need to know how the rooms are arranged inside; you just ask for a room number and get the key or information.

Class MyCollection
╔════════════════════════╗
║ private data storage   ║
║ ┌──────────────────┐ ║
║ │ array or list    │ ║
║ └──────────────────┘ ║
║                      ║
║ indexer: this[int i] ║
║ ┌ get { return data[i]; }  ║
║ └ set { data[i] = value; } ║
╚════════════════════════╝

Usage:
myCollection[3] = 10;  // sets value at index 3
int x = myCollection[3]; // gets value at index 3

Build-Up - 7 Steps

1

Foundation

Understanding basic properties

Concept: Properties let you get or set values in a class using simple syntax.

In C#, properties are like variables inside classes but with special get and set methods. For example: public class Person { private string name; public string Name { get { return name; } set { name = value; } } } You can use person.Name to get or set the name safely.

Result

You can access and modify private data through properties with simple syntax.

Understanding properties is essential because indexers work similarly but use an index instead of a property name.

2

Foundation

Using arrays and indexing basics

Concept: Arrays store multiple values accessible by numeric indexes starting at zero.

An array holds many values of the same type. You access elements by their position: int[] numbers = {10, 20, 30}; int first = numbers[0]; // 10 numbers[1] = 25; // changes second element Indexes let you quickly find or change values inside arrays.

Result

You can retrieve or update values in arrays using square brackets and an index.

Knowing how arrays work helps you understand how indexers let objects behave like arrays.

3

Intermediate

Declaring a simple indexer

🤔Before reading on: do you think an indexer uses a method name or a special keyword? Commit to your answer.

Concept: Indexers use the 'this' keyword with parameters to define how to access elements by index.

Inside a class, you declare an indexer like this: public class Sample { private int[] data = new int[5]; public int this[int index] { get { return data[index]; } set { data[index] = value; } } } You use it like an array: Sample s = new Sample(); s[0] = 100; int x = s[0];

Result

The object s can be accessed with square brackets to get or set values.

Knowing that 'this' with parameters defines an indexer clarifies how C# treats objects like arrays.

4

Intermediate

Indexers with multiple parameters

🤔Do you think indexers can only have one index parameter? Commit to yes or no.

Concept: Indexers can have more than one parameter to support multi-dimensional access.

You can declare indexers with multiple indexes, like for a matrix: public class Matrix { private int[,] data = new int[3,3]; public int this[int row, int col] { get { return data[row, col]; } set { data[row, col] = value; } } } Usage: Matrix m = new Matrix(); m[1,2] = 5; int val = m[1,2];

Result

You can access elements using multiple indexes inside square brackets.

Understanding multi-parameter indexers expands how you can model complex data structures.

5

Intermediate

Read-only and write-only indexers

🤔Can an indexer be write-only or read-only? Commit to yes or no.

Concept: Indexers can have only get or only set accessors to control how they are used.

You can make an indexer read-only by only providing get: public int this[int i] { get { return data[i]; } } Or write-only by only providing set: public int this[int i] { set { data[i] = value; } } This controls whether users can read, write, or both.

Result

Indexers can restrict access to data by limiting get or set.

Knowing how to control access with indexers helps enforce data safety and encapsulation.

6

Advanced

Using indexers with interfaces

🤔Do you think interfaces can require indexers? Commit to yes or no.

Concept: Interfaces can declare indexers to enforce that implementing classes provide indexed access.

An interface can declare an indexer like this: public interface IStringCollection { string this[int index] { get; set; } } A class implementing it must define the indexer: public class MyStrings : IStringCollection { private string[] data = new string[10]; public string this[int index] { get { return data[index]; } set { data[index] = value; } } } This ensures consistent access patterns.

Result

Interfaces can require indexers, enabling polymorphic indexed access.

Understanding indexers in interfaces helps design flexible and consistent APIs.

7

Expert

Indexer performance and pitfalls

🤔Do you think indexers always have the same performance as direct array access? Commit to yes or no.

Concept: Indexers are methods under the hood, so their performance depends on implementation and can differ from direct array access.

Although indexers look like array access, they compile to get_ and set_ methods. If these methods do complex work, performance can slow down. Example: public int this[int i] { get { Console.WriteLine("Accessing index " + i); return data[i]; } set { Console.WriteLine("Setting index " + i); data[i] = value; } } This adds overhead compared to direct array access. Also, indexers can throw exceptions if indexes are invalid, so always validate indexes.

Result

Indexer calls may be slower than direct array access and can throw exceptions if misused.

Knowing indexers are methods helps avoid hidden performance costs and runtime errors.

Under the Hood

Indexers in C# are compiled into special get_ and set_ methods named get_Item and set_Item by default. When you use square brackets, the compiler translates that into calls to these methods. This means indexers are syntactic sugar for methods that take parameters and return or set values. The runtime calls these methods just like any other method, allowing flexibility but adding a small overhead compared to direct array access.

Why designed this way?

C# designers wanted a clean, readable way to access elements inside objects without exposing internal data structures. Using the 'this' keyword with parameters allows indexers to look like array access but behave like methods, enabling validation, logging, or custom logic. This design balances ease of use with flexibility and safety, unlike exposing public arrays directly which can lead to bugs.

Object with indexer
╔════════════════════════════╗
║ Class with private storage ║
║ ┌──────────────────────┐ ║
║ │ private array/list   │ ║
║ └──────────────────────┘ ║
║                          ║
║ Indexer: this[int index]  ║
║ ┌ get_Item(index)       ┐ ║
║ │ return data[index];   │ ║
║ └──────────────────────┘ ║
║ ┌ set_Item(index, value) ┐ ║
║ │ data[index] = value;  │ ║
║ └──────────────────────┘ ║
╚════════════════════════════╝

Usage:
myObject[2]  → calls get_Item(2)
myObject[2] = 5 → calls set_Item(2, 5)

Myth Busters - 4 Common Misconceptions

Quick: Does an indexer create a new array each time you access it? Commit to yes or no.

Common Belief: Indexers create a new array or copy of data every time you use them.

Reality: Indexers access existing data inside the object; they do not create new arrays or copies unless explicitly coded to do so.

Why it matters: Believing this causes unnecessary performance worries or redundant code, leading to inefficient designs.

Quick: Can indexers have different names like normal methods? Commit to yes or no.

Common Belief: Indexers have their own unique names and can be called like normal methods.

Reality: Indexers always use the 'this' keyword and do not have explicit names; they are accessed only via square brackets.

Why it matters: Misunderstanding this leads to confusion about how to call or override indexers.

Quick: Can you overload indexers by changing only the return type? Commit to yes or no.

Common Belief: You can overload indexers by changing just the return type while keeping parameters the same.

Reality: Indexers cannot be overloaded by return type alone; parameter types or counts must differ.

Why it matters: Trying to overload indexers incorrectly causes compilation errors and wasted time.

Quick: Do indexers always behave exactly like arrays in performance and behavior? Commit to yes or no.

Common Belief: Indexers are exactly like arrays in speed and behavior.

Reality: Indexers are methods and can include extra logic, so their performance and behavior can differ from arrays.

Why it matters: Assuming identical behavior can cause unexpected slowdowns or bugs in production.

Expert Zone

1

Indexers can be explicitly implemented for interfaces, making them accessible only through the interface reference, which helps control API exposure.

2

You can define indexers with different parameter types, not just integers, enabling dictionary-like access patterns.

3

Indexers can throw exceptions for invalid indexes, so defensive programming is essential to avoid runtime crashes.

When NOT to use

Avoid indexers when your data access requires complex queries or multiple keys that don't fit well into simple index parameters. Instead, use methods with descriptive names or specialized collection classes like Dictionary for key-based access.

Production Patterns

In real-world code, indexers are often used in collection classes, custom data containers, or wrappers around arrays to provide safe and intuitive access. They are combined with interfaces like IList to create flexible APIs. Explicit interface implementation of indexers is common to hide them from public APIs while supporting polymorphism.

Connections

Properties in C#

Indexers are like properties but use parameters to access data.

Understanding properties helps grasp indexers because both use get/set accessors to control data access.

Operator overloading

Both indexers and operator overloading let objects behave like built-in types with special syntax.

Knowing how operator overloading works clarifies how C# allows custom syntax for objects, including indexers.

Database query indexing

Indexers conceptually resemble database indexes that let you quickly access data by keys or positions.

Seeing indexers as a way to 'look up' data by keys connects programming to how databases optimize data retrieval.

Common Pitfalls

#1 Accessing indexer without validating index range

Wrong approach:

int value = myCollection[10]; // index 10 may be out of range

Correct approach:

if (index >= 0 && index < myCollection.Length) {
int value = myCollection[index];
}

Root cause:

Assuming indexers automatically check bounds or ignoring possible invalid indexes.

#2 Trying to overload indexers by return type only

Wrong approach:

public int this[int i] { get; set; }
public string this[int i] { get; set; } // error

Correct approach:

public int this[int i] { get; set; }
public string this[string key] { get; set; } // different parameter type

Root cause:

Misunderstanding C# method overloading rules which require different parameter lists.

#3 Exposing internal arrays publicly instead of using indexers

Wrong approach:

public int[] data; // public array field

Correct approach:

private int[] data;
public int this[int i] {
get { return data[i]; }
set { data[i] = value; }
}

Root cause:

Not understanding encapsulation and the benefits of controlled access through indexers.

Key Takeaways

Indexers let objects be accessed like arrays using square brackets and indexes.

They are declared using the 'this' keyword with parameters inside classes or structs.

Indexers compile into get_ and set_ methods, so they behave like methods with syntax sugar.

You can control access by providing only get or set accessors, and support multiple parameters.

Understanding indexers improves code readability, safety, and flexibility when working with collections.