C#索引器学习笔记

    本笔记摘抄自：https://www.cnblogs.com/armyshen/archive/2012/08/27/2659405.html，记录一下学习过程以备后续查用。

    索引器允许类或者结构的实例按照与数组相同的方式进行索引取值，索引器与属性类似，不同的是索引器的访问是带参的。

    索引器和数组比较：

    1)索引器的索引值(index)类型不受限制

    2)索引器允许重载

    3)索引器不是一个变量

    索引器和属性的不同点：

    1)属性以名称来标识，索引器以函数形式标识。

    2)索引器可以被重载，属性不可以。

    3)索引器不能声明为static，属性可以。

    一、下面代码演示一个简单的索引器：

    class program
    {
        /// <summary>
        /// 简单的索引器类
        /// </summary>
        public class simpleindexerclass
        {
            private readonly string[] name = new string[2];

            /// <summary>
            /// 索引器必须以this关键字定义，其实这个this就是类实例化之后的对象。
            /// </summary>
            /// <param name="index"></param>
            /// <returns></returns>
            public string this[int index]
            {
                get //实现索引器的get方法
                {
                    if (index < 2)
                    {
                        return name[index];
                    }
                    return null;
                }
                set //实现索引器的set方法
                {
                    if (index < 2)
                    {
                        name[index] = value;
                    }
                }
            }
        }

        static void main(string[] args)
        {
            #region 简单的索引器
            //索引器的使用
            simpleindexerclass indexer = new simpleindexerclass();
            //“=”号右边对索引器赋值，其实就是调用其set方法。
            indexer[0] = "张三";
            indexer[1] = "李四";
            //输出索引器的值，其实就是调用其get方法。
            console.writeline(indexer[0]);
            console.writeline(indexer[1]);
            console.read();
            #endregion
        }
    }

    运行结果如下：

    二、下面代码演示以字符串作为下标，对索引器进行存取。

    class program
    {
        /// <summary>
        /// 以字符串作为下标，对索引器进行存取。
        /// </summary>
        public class stringindexerclass
        {
            //用string作为索引器下标的时候，要用hashtable。
            private hashtable name = new hashtable();

            /// <summary>
            /// 索引器必须以this关键字定义，其实这个this就是类实例化之后的对象。
            /// </summary>
            /// <param name="index"></param>
            /// <returns></returns>
            public string this[string index]
            {
                get
                {
                    return name[index].tostring();
                }
                set
                {
                    name.add(index, value);
                }
            }
        }

        static void main(string[] args)
        {
            #region 以字符串作为下标，对索引器进行存取。
            stringindexerclass indexer = new stringindexerclass();
            indexer["a0001"] = "张三";
            indexer["a0002"] = "李四";
            console.writeline(indexer["a0001"]);
            console.writeline(indexer["a0002"]);
            console.read();
            #endregion
        }
    }

    运行结果如下：

    三、下面代码演示索引器的重载。

    class program
    {
        /// <summary>
        /// 索引器的重载
        /// </summary>
        public class overloadindexerclass
        {
            private hashtable name = new hashtable();

            //第一种索引器：通过key存取values
            public string this[int index]
            {
                get
                {
                    return name[index].tostring();
                }
                set
                {
                    name.add(index, value);
                }
            }

            //第二种索引器：通过values存取key
            public int this[string addname]
            {
                get
                {
                    //hashtable中实际存放的是dictionaryentry(字典)类型
                    //如果要遍历一个hashtable，就需要使用到dictionaryentry。
                    foreach (dictionaryentry dict in name)
                    {
                        if (dict.value.tostring() == addname)
                        {
                            return convert.toint32(dict.key);
                        }
                    }
                    return -1;
                }
                set
                {
                    name.add(value, addname);
                }
            }
        }

        static void main(string[] args)
        {
            #region 索引器的重载
            overloadindexerclass indexer = new overloadindexerclass();

            //第一种索引器的使用
            indexer[1] = "张三";  //set访问器的使用
            indexer[2] = "李四";
            console.writeline("编号为1的名字：" + indexer[1]); //get访问器的使用
            console.writeline("编号为2的名字：" + indexer[2]);
            console.writeline();

            //第二种索引器的使用
            console.writeline("张三的编号是：" + indexer["张三"]);   //get访问器的使用
            console.writeline("李四的编号是：" + indexer["李四"]);
            indexer["王五"] = 3;  //set访问器的使用
            console.writeline("王五的编号是：" + indexer["王五"]);
            console.read();
            #endregion
        }
    }

    运行结果如下：

    四、多参索引器

    class program
    {
        /// <summary>
        /// 入职信息类
        /// </summary>
        public class entrantinfo
        {
            //工号
            public int jobnumber { get; set; }
            //姓名
            public string name { get; set; }
            //部门
            public string department { get; set; }
            /// <summary>
            /// 无参构造函数
            /// </summary>
            public entrantinfo()
            {

            }
            /// <summary>
            /// 有参构造函数
            /// </summary>
            /// <param name="jobnumber">工号</param>
            /// <param name="name">姓名</param>
            /// <param name="department">部门</param>
            public entrantinfo(int jobnumber, string name, string department)
            {
                jobnumber = jobnumber;
                name = name;
                department = department;
            }
        }

        //声明一个类entrantinfo的索引器
        public class entrantinfoindexerclass
        {
            private readonly arraylist arraylist;    //用于存放entrantinfo类
            public entrantinfoindexerclass()
            {
                arraylist = new arraylist();
            }

            //声明一个索引器：以姓名及部门查找工号。
            public int this[string name, string department]
            {
                get
                {
                    foreach (entrantinfo ei in arraylist)
                    {
                        if (ei.name == name && ei.department == department)
                        {
                            return ei.jobnumber;
                        }
                    }
                    return -1;
                }
                set
                {
                    //new关键字：c#规定，实例化一个类或者调用类的构造函数时，必须使用new关键。
                    arraylist.add(new entrantinfo(value, name, department));
                }
            }

            //声明一个索引器：以工号查找姓名和部门。
            public arraylist this[int jobnumber]
            {
                get
                {
                    arraylist alfind = new arraylist();
                    foreach (entrantinfo ei in arraylist)
                    {
                        if (ei.jobnumber == jobnumber)
                        {
                            alfind.add(ei);
                        }
                    }
                    return alfind;
                }
            }

            //还可以声明多个版本的索引器...
        }

        static void main(string[] args)
        {
            #region 多参索引器
            entrantinfoindexerclass indexer = new entrantinfoindexerclass();
            //this[string name, string department]的使用
            indexer["张三", "行政人事部"] = 101;
            indexer["李四", "行政人事部"] = 102;
            console.writeline("行政人事部张三的工号：" + indexer["张三", "行政人事部"]);
            console.writeline("行政人事部李四的工号：" + indexer["李四", "行政人事部"]);
            console.writeline();
            //this[int jobnumber]的使用
            foreach (entrantinfo ei in indexer[101])
            {
                console.writeline("工号101的姓名：" + ei.name);
                console.writeline("工号101的部门：" + ei.department);
            }
            console.read();
            #endregion
        }
    }

    运行结果如下：