简介

索引器（Indexer）是 C# 中的一种特殊属性，它允许类或结构体像数组一样使用索引语法（例如 obj[0]）来访问或修改对象内部的成员。简单来说，它将对象的实例视为“可索引的集合”，提供类似于数组的访问方式。

• 核心特性：

  • 类似于属性（Property），但带有参数（通常是索引值，如整数或字符串）。

  • 支持 get 和 set 访问器，与属性类似。

  • 可以重载（overload），允许不同类型的索引参数。

  • 语法：public 类型 this[参数类型 参数名] { get { ... } set { ... } }

• 适用范围：类、结构体、接口。不能在委托或枚举中使用。

索引器本质上是方法（get/set），但编译器将其转换为特殊的属性调用，隐藏了底层实现细节。

语法结构：

public <返回类型> this[<参数类型> index]
{
    get { ... }
    set { ... }
}

• this[...] 表示作用于当前对象实例。

• 可以有多个索引参数（如二维索引）。

为什么使用索引器？

在面向对象编程中，直接暴露内部数组或集合（如 public int[] Data { get; }）会破坏封装性（客户端可随意修改）。索引器提供受控访问：

• 封装性：隐藏内部存储（如 List、Dictionary），允许验证、转换或缓存逻辑。

• 直观性：代码更像数组操作，提升可读性（e.g., cache["key"] = value; 而非 cache.Set("key", value);）。

• 适用场景：

  • 模拟数组/集合（如自定义列表、矩阵）。

  • 字典式访问（字符串键）。

  • 多维数据（如图像像素访问）。

  • 与 LINQ 或 foreach 集成（需实现 IEnumerable）。

索引器在 C# 中提供了类似数组的访问语法，但其本质是带有参数的属性。与普通方法相比，索引器语法更为简洁；与常规属性相比，它支持通过参数进行动态访问。这种设计使得代码既直观又灵活。

基本示例

以下是一个简单的索引器定义示例：

public class MyList
{
    private string[] _data = new string[5];

    public string this[int index]
    {
        get => _data[index];
        set => _data[index] = value;
    }
}

在客户端代码中，我们可以这样使用它：

var list = new MyList();
list[0] = "Hello";
list[1] = "World";

Console.WriteLine(list[0]); // 输出：Hello
Console.WriteLine(list[1]); // 输出：World

尽管语法看起来与数组访问完全一致，但底层机制实际上是调用属性访问器。这种抽象隐藏了内部实现细节，提升了代码的可读性。

索引器与属性的关系

索引器本质上是一种特殊的属性，它必须包含至少一个参数。与无参属性不同，索引器允许通过不同的索引值访问对象内部的不同部分。这种特性使得索引器非常适合用于封装集合或映射数据结构。

索引器的底层机制

从 IL 代码的角度来看，索引器会被编译为特定的方法调用：

obj[index]

具体来说，编译器会将索引器访问转换为对名为 Item 的方法调用。该方法是一对 get/set 方法，分别对应 get 和 set 访问器。这些方法在 CLR 级别上被标记，确保了访问的安全性和规范性。

不同类型的索引器

整数索引器

这是最常见的索引器类型，通常用于模拟数组行为。通过整数索引，可以快速访问集合中的特定元素。

public class IntArrayWrapper
{
    private int[] _array;

    public IntArrayWrapper(int size)
    {
        _array = new int[size];
    }

    public int this[int index]
    {
        get => _array[index];
        set => _array[index] = value;
    }

    public int Length => _array.Length;
}

// 使用
var wrapper = new IntArrayWrapper(5);
wrapper[0] = 10;
wrapper[1] = 20;
Console.WriteLine(wrapper[0]); // 输出: 10

字符串索引器

字符串索引器允许通过键名访问值，类似于字典的行为。这种类型在配置管理或缓存系统中非常有用。

public class DictionaryWrapper
{
    private Dictionary<string, string> _dictionary = new Dictionary<string, string>();

    public string this[string key]
    {
        get
        {
            _dictionary.TryGetValue(key, out string value);
            return value;
        }
        set
        {
            _dictionary[key] = value;
        }
    }
}

// 使用
var dictWrapper = new DictionaryWrapper();
dictWrapper["name"] = "John";
dictWrapper["age"] = "30";

Console.WriteLine(dictWrapper["name"]); // 输出: John

多参数索引器

支持多个参数的索引器可以处理更复杂的数据结构，如二维数组或矩阵。通过组合多个索引，可以实现多维数据的访问。

public class Matrix
{
    private double[,] _matrix;

    public Matrix(int rows, int columns)
    {
        _matrix = new double[rows, columns];
    }

    // 多参数索引器
    public double this[int row, int column]
    {
        get => _matrix[row, column];
        set => _matrix[row, column] = value;
    }

    public int Rows => _matrix.GetLength(0);
    public int Columns => _matrix.GetLength(1);
}

// 使用
var matrix = new Matrix(3, 3);
matrix[0, 0] = 1.0;
matrix[1, 1] = 2.0;
matrix[2, 2] = 3.0;

Console.WriteLine(matrix[1, 1]); // 输出: 2.0

重载索引器

同一个类可以定义多个重载的索引器，只要它们的参数类型不同。这提供了极大的灵活性，允许根据上下文选择最合适的访问方式。

public class MultiIndexCollection
{
    private List<string> _items = new List<string>();

    public void Add(string item) => _items.Add(item);

    // 整数索引器
    public string this[int index]
    {
        get => _items[index];
        set => _items[index] = value;
    }

    // 字符串索引器 - 通过名称查找
    public string this[string name]
    {
        get => _items.Find(item => item.StartsWith(name));
    }
}

// 使用
var collection = new MultiIndexCollection();
collection.Add("Apple");
collection.Add("Banana");
collection.Add("Cherry");

Console.WriteLine(collection[0]);    // 输出: Apple
Console.WriteLine(collection["B"]);  // 输出: Banana

高级用法

只读索引器

可以通过省略 set 访问器来创建只读索引器，防止外部修改数据：

public class Settings
{
    private readonly Dictionary<string, string> _values = new();

    public string this[string key]
    {
        get => _values.TryGetValue(key, out var value)  value : string.Empty;
        set => _values[key] = value;
    }
}

使用方式如下：

var s = new Settings();
s["Language"] = "Chinese";
s["Theme"] = "Dark";

Console.WriteLine(s["Language"]); // Chinese

同理，只写索引器通过省略 get 访问器实现：

public string this[int index]
{
    set => _data[index] = value;
}

索引器可以被继承或重写

在面向对象设计中，索引器可以像普通方法一样被继承和重写：

父类定义：

public class Base
{
    public virtual string this[int index]
    {
        get => $"Base:{index}";
        set => Console.WriteLine($"Set Base[{index}]={value}");
    }
}

子类重写：

public class Derived : Base
{
    public override string this[int index]
    {
        get => $"Derived:{index}";
        set => Console.WriteLine($"Set Derived[{index}]={value}");
    }
}

接口中的索引器

接口可以声明索引器，强制实现类提供特定的访问机制：

public interface IListContainer<T>
{
    T this[int index] { get; set; }
    int Count { get; }
}

public class MyList<T> : IListContainer<T>
{
    private List _items = new List();

    public T this[int index]
    {
        get => _items[index];
        set => _items[index] = value;
    }

    public int Count => _items.Count;

    public void Add(T item) => _items.Add(item);
}

实际应用示例

配置管理器

在配置系统中，索引器常用于通过键名快速获取配置项：

public class Configuration
{
    private readonly Dictionary<string, object> _settings = new Dictionary<string, object>();

    public object this[string key]
    {
        get => _settings.TryGetValue(key, out object value)  value : null;
        set => _settings[key] = value;
    }

    public T Get<T>(string key, T defaultValue = default)
    {
        if (_settings.TryGetValue(key, out object value) && value is T typedValue)
        {
            return typedValue;
        }
        return defaultValue;
    }
}

// 使用
var config = new Configuration();
config["DatabaseConnection"] = "Server=localhost;Database=Test;";
config["Timeout"] = 30;

string connection = config.Get<string>("DatabaseConnection");
int timeout = config.Get<int>("Timeout");

自定义集合类

封装自定义集合时，索引器提供了标准的访问接口：

public class SmartCollection<T>
{
    private T[] _items;
    
    public SmartCollection(int size) => _items = new T[size];
    
    public T this[int index]
    {
        get => _items[index];
        set => _items[index] = value;
    }
    
    // 重载索引器
    public T this[string name] => FindByName(name);
    
    private T FindByName(string name)
    {
        // 根据名称查找逻辑...
    }
}

数据访问层封装

在数据库访问中，索引器可以简化数据行的访问逻辑：

public class DataRepository
{
    private List _customers = new();
    
    public Customer this[int id]
    {
        get => _customers.FirstOrDefault(c => c.Id == id);
    }
    
    public Customer this[string email]
    {
        get => _customers.FirstOrDefault(c => c.Email == email);
    }
}

索引器与其他特性结合

索引器与泛型

泛型索引器允许类型安全的集合访问：

public class GenericCollection<T>
{
    private T[] _items = new T[10];
    
    public T this[int index]
    {
        get => _items[index];
        set => _items[index] = value;
    }
}

索引器与模式匹配（C# 8.0+）

结合模式匹配，可以更灵活地处理索引结果：

if (collection is IIndexable<int, string> indexable)
{
    Console.WriteLine(indexable[0]);
}

索引器与范围支持（C# 8.0+）

利用范围操作符，可以高效地访问连续的数据片段：

public class RangeCollection
{
    private int[] _items = {1, 2, 3, 4, 5};
    
    public int[] this[Range range]
    {
        get => _items[range];
    }
}

// 使用
var collection = new RangeCollection();
int[] sub = collection[1..4]; // [2, 3, 4]

常见应用场景

索引器广泛应用于需要频繁访问内部数据的场景，如缓存系统、配置管理、自定义集合以及数据映射等。合理使用索引器可以显著提升代码的可读性和维护性。