C#索引器

索引器是一种特殊的类成员，它能够让对象以类似数组的方式来存取，使程序看起来更为直观，更容易编写。

1、索引器的定义

C#中的类成员可以是任意类型，包括数组和集合。当一个类包含了数组和集合成员时，索引器将大大简化对数组或集合成员的存取操作。

定义索引器的方式与定义属性有些类似，其一般形式如下：

[修饰符] 数据类型 this[索引类型 index]
{
    get{//获得属性的代码}
    set{ //设置属性的代码}
}

修饰符包括 public,protected,private,internal,new,virtual,sealed,override, abstract,extern.

数据类型是表示将要存取的数组或集合元素的类型。

索引器类型表示该索引器使用哪一类型的索引来存取数组或集合元素，可以是整数，可以是字符串；this表示操作本对象的数组或集合成员，可以简单把它理解成索引器的名字，因此索引器不能具有用户定义的名称。 例如： 

class Z
{
    //可容纳100个整数的整数集
    private long[] arr = new long[100];
    //声明索引器
    public long this[int index]
    {
        get
        { //检查索引范围
            if (index < 0 || index >= 100)
            {
                return 0;
            }
            else
            {
                return arr[index];
            }
        }
        set
        {
            if (!(index < 0 || index >= 100))
            {
                arr[index] = value;
            }
        }
    }
}

 

2、索引器的使用

通过索引器可以存取类的实例的数组成员，操作方法和数组相似，一般形式如下：

对象名[索引]

其中索引的数据类型必须与索引器的索引类型相同。例如：

Z z=new z();
z[0]=100;
z[1]=101;
Console.WriteLine(z[0]);

表示先创建一个对象z，再通过索引来引用该对象中的数组元素。

 

3、接口中的索引器

在接口中也可以声明索引器，接口索引器与类索引器的区别有两个：一是接口索引器不使用修饰符；二是接口索引器只包含访问器get或set，没有实现语句。访问器的用途是指示索引器是可读写、只读还是只写的，如果是可读写的，访问器get或set均不能省略；如果只读的，省略set访问器；如果是只写的，省略get访问器。

例如：

public interface IAddress
{
    string this[int index]{get;set;}
    string Address{get;set;}
    string Answer();
}

表示所声明的接口IAddress包含3个成员：一个索引器、一个属性和一个方法，其中，索引器是可读写的。

 

4、索引器与属性的比较

索引器与属性都是类的成员，语法上非常相似。索引器一般用在自定义的集合类中，通过使用索引器来操作集合对象就如同使用数组一样简单；而属性可用于任何自定义类，它增强了类的字段成员的灵活性。

属        性	索  引  器
允许调用方法，如同公共数据成员	允许调用对象上的方法，如同对象是一个数组
可通过简单的名称进行访问	可通过索引器进行访问
可以为静态成员或实例成员	必须为实例成员
其get访问器没有参数	其get访问器具有与索引器相同的形参表
其set访问器包含隐式value参数	除了value参数外，其set访问器还具有与索引器相同的形参表

 

另一个索引器的例子：

//类的定义
public class Person
{
    //定义两个字段信息
    private string name;
    private string password;

    //定义一个 Name 属性来操作 name 字段
    public string Name
    {
        set { name = value; }
        get { return name; }
    }

    //定义一个 Password 属性来操作 password 字段
    public string Password
    {
        set { password = value; }
        get { return password; }
    }

    //定义索引器，name 字段的索引值为 0 ，password 字段的索引值为 1
    public string this[int index]
    {
        get
        {
            if (index == 0) 
                return name;
            else if (index == 1) 
                return password;
            else 
                return null;
        }
        set
        {
            if (index == 0) 
                name = value;
            else if (index == 1) 
                password = value;
        }
    }
}


//索引器使用
protected void Page_Load(object sender, EventArgs e)
{
    //声明并实例化这个类
    Person p = new Person();

    //使用索引器的方式来给类的两个属性赋值
    p[0] = "jarod";
    p[1] = "123456,./";

    //使用类属性取得两个字段信息
    Label1.Text = p.Name + " / " + p.Password;
}

 

又一个例子：

namespace ConsoleApplication1
{
    public class Program
    {
        public static void Main(string[] args)
        {
            // 调用子类的索引器
            Test_Child test = new Test_Child();
            Console.WriteLine(test[1]); // 通过索引器得到一个值并输出
            test[1] = "John";   // 通过索引器改变一个值
            Console.WriteLine(test["Johness2"]);
            Console.WriteLine(test[1]); // 再次输出
            Console.WriteLine("---------------------------------------");
            //输出:
            // Johness2
            // -1
            // John
            //---------------------------------------

            // 调用父类的索引器，完成与子类的比较
            Test_Base tb = new Test_Base(); // 父类引用保存父类变量
            Test_Base tc = test;            // 父类引用保存子类变量
            Console.WriteLine(tb[2]);       // 父类索引器被调用
            Console.WriteLine(tc[2]);       // 还是父类索引器被调用（因为子类相同入参的索引器向父类隐藏了！由于是实例成员，可能二义性的成员都会被隐藏）
            Console.WriteLine((tc as Test_Child)[2]);   // 显式地调用子类索引器
            Console.ReadKey();
            // 输出 :
            // 3
            // 3
            // Johness3
        }
    }

    public class Test_Child : Test_Base
    {
        // 定义用于实验的字符串数组
        string[] testStrings = { "Johness1", "Johness2", "Johness3", "Johness4", "Johness5", "Johness6" };

        // 一个类中可以定义多个索引器
        // 可以理解为索引器的重载
        // 只要入参类型不同即可（所有索引器的入参集合中）
        // 这意味着您若添加以下代码也能通过编译并运行正常
        // public int this[double index] { get { return 0; } }
        // public string this[char index] { get { return null; } }
        public int this[string index]
        {
            get
            {
                for (int i = 0; i < testStrings.Length; i++)
                {
                    if (testStrings[i] == index)
                    {
                        return i;
                    }
                }
                return -1;
            }
        }

        // 定义索引器
        // 由于与父类的索引器入参一样，编译器会报警告
        // 可以添加new修饰符，当然，如果不添加也不会有问题
        new public string this[int index]
        {
            get { return testStrings[index]; }
            set { testStrings[index] = value; }
        }

    }

    // 父类
    public class Test_Base
    {
        int[] testInts = { 1, 2, 3, 4, 5, 6 };
        // 只读的索引器
        public int this[int index]
        {
            get { return testInts[index]; }
        }
    }
}