C#访问器、索引器和运算符浅析

　　C#语言虽然诞生不久，但却因其高度的封装性和对其他早期语言的良好兼容使程序员的代码编写变得轻松加愉快。本文将对C#里的访问器、索引器及运算符进行简单的探讨。

　　其实说道这些大家应该都有印象，即使刚刚接触编程的朋友应该也或多或少地使用过这些语法，具体的定义和概念我就不再赘述，我们通过下面的例子来认识什么是访问器： 

using System;

namespace AccessorEG
{
    public class Student
    {
        // 私有字段 private field
        private int _age;

        // 公开的属性 public property
        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student();
            stu.Age = 10;   // 使用了修改
            Console.WriteLine(stu.Age.ToString());  // 使用了读取
            Console.ReadKey();
            // 输出 10
        }
    }
}

　　很好理解，访问器就是指对象类型成员对外界的借口，就是使对象类型成员与外界进行信息交互的桥梁，有了访问器，外界就能对对象成员进行读、写的对应操作。

　　那么，什么成员能够拥有访问器呢？非只读的字段和事件是可以声明访问器的。当然，只读域也能提供被外界获取的借口，即get，但是只能在声明或构造函数中初始化，而且它并不支持提供set方法，除了将其对象替换，我实在找不出更改它的办法。

using System;

namespace AccessorEG
{
    public class Student
    {
        // 私有字段 private field
        private readonly int _age = 10;

        // 公开的属性 public property
        public int Age
        {
            get { return _age; }
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student();
            Console.WriteLine(stu.Age.ToString());  // 使用了读取
            Console.ReadKey();
            // 输出 10
        }
    }
}

　　上述代码中只读域的值在声明时就已经赋了，而它对应公开属性的访问器中也不能提供set方法，不然会无法通过编译，但是它可以被外界取得。

　　关于字段的访问器我们还要说一些，常见的有以下写法：

using System;

namespace AccessorEG
{
    public class Student
    {
        #region 全访问权限
        // 私有字段
        private int _age;
        // 与_age对应的公开属性，包含了set和get方法
        public int Age
        {
            get { return _age; }
            set { _age = value; }
        }

        // 如果您安装了.NET3.0，那么您可以使用自动属性，届时，上面的代码即可以下面的代替
　　　　 // 在VS.NET下输入 prop 连击两下Tab键，编译器会自动帮您生成自动属性
　　　　 // public int Age { get; set; }
        #endregion // 全访问权限

        #region 只读属性
        private string _name;

        public string Name
        {
            get { return _name; }
        }

        // 等同于
　　　　 // public string Name { private set; get; }
        #endregion

        #region 只写属性
        private bool _sex;

        public bool Sex
        {
            set { _sex = value; }
        }
        // 等同于
　　　　 // public bool Sex { set; private get; }
        #endregion

    }

    class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student();
            stu.Age = 18;
            // stu.Name = "Johness"; 异常，编译错误，因为该属性只读
　　　　　　  // Console.WriteLine(stu.Sex.ToString());   异常，编译错误，因为该属性只写
            Console.WriteLine(stu.Age.ToString());  // 使用了读取
            Console.ReadKey();
            // 输出 18
        }
    }
}

　　以上示例中的只读、只写仅对外界有效，如果您显示得制定了该访问器的所有者，即类的私有字段。那么在类的内部，您仍可以方便的使用您定义的私有字段进行读写操作，因此，我建议朋友们定义字段及其访问器使用.NET2.0的语法而不用3.0的新语法（自动属性）。当然，利用访问器也能更好地对数据有效性进行验证：

using System;

namespace AccessorEG
{
    public class Student
    {
        // 私有字段
        private int _age;
        // 与_age对应的公开属性，包含了set和get方法
        public int Age
        {
            get { return _age; }
            // 利用访问器对输入的年龄进行验证
　　　　　　  // 如果输入值小于0或者大于100
　　　　　　  // 可以赋为默认值18或者不进行操作
            set 
            {
                if (value >= 0 && value <= 100)
                    _age = value;
                    // 如果数据无效不进行操作可以注释以下内容
                else
                    _age = 18;
            }
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            Student stu = new Student();
            stu.Age = -2;   // 赋无效值
            Console.WriteLine(stu.Age.ToString()); 
            Console.ReadKey();
            // 输出 18
        }
    }
}

　　字段的访问器我们就介绍到这里，接下来看看事件的访问器。事件的访问器和字段的访问器类似，基本上只是将set,get换成了add,remove。

　　我们平时使用事件的时候只管一通+= 、-=，到了事件的访问器了却进行了如下操作：

using System;

namespace AccessorEG
{
    // 定义委托
    public delegate void TestEventHandler();

    public class Program
    {
        // 委托类型成员
        private TestEventHandler _testEvent;
        // 封装过后的事件
        public event TestEventHandler TestEvent
        {
            add 
            {
                _testEvent += value;
            }
            remove 
            {
                _testEvent -= value;
            }
        }
    }
}

　　使用过事件的朋友可能都知道，事件可以理解为是委托的封装。那么这个add和remove就十分容易理解了，和set、get没什么区别。

　　但是事件的add和remove不能缺，和自动属性有一点类似，而且add和remove必须有主体。

　　但是您可以利用自定义事件访问器实现如下操作：

using System;

namespace AccessorEG
{
    // 定义委托
    public delegate void TestEventHandler();

    public class Program
    {
        // 委托类型成员
        private TestEventHandler _testEvent;
        // 封装过后的事件
        public event TestEventHandler TestEvent
        {
            add 
            {
                _testEvent += value;
            }
            remove { }  // 1.您可以在add或remove主体内不进行任何操作

　　　　　　 // add 
　　　　　   // {        // 2.您可以在add方法主体内更新委托绑定的方法而不是增加，即可以使委托（或事件）只绑定最后一个指定方法
　　　　　  //      _testEvent = value;
　　　　　　// }
　　　　　　// remove { // …… }
        }
    }
}

　　事件的访问器没什么需要赘述的，当然，更多的我也不知道……

　　那么，下面我们看看C#的索引器语法有什么神奇的地方。

using System;
using System.Collections;
using System.Collections.Generic;

namespace IndexerEG
{
    public class Program
    {
        public static void Main(string[] args)
        {
            // 先声明数组，多种方式可供选择
            int[] array = new int[3] { 1, 2, 3 };
            // 由于数组不容易观察，我们选用泛型集合List来查看索引器
            IList<int> list = new List<int>(array);
            Console.WriteLine(list[2].ToString());
            // 输出 3
        }
    }
}

　　我们看一下系统定义的索引器方法签名：

// 摘要:
//     获取或设置指定索引处的元素。
//
// 参数:
//   index:
//     要获得或设置的元素从零开始的索引。
//
// 返回结果:
//     指定索引处的元素。
//
// 异常:
//   System.ArgumentOutOfRangeException:
//     index 不是 System.Collections.Generic.IList<T> 中的有效索引。
//
//   System.NotSupportedException:
//     设置该属性，而且 System.Collections.Generic.IList<T> 为只读。
        T this[int index] { get; set; }

　　从System.Collections.Generic命名空间下的IList<T>中可以看到，看起来，说它是方法是极不准确的了。它更像一个拥有访问器的字段，只是拥有更多神奇的地方，我们可以大胆地分析一下（T在此处是泛型，泛指任意类型）：

　　在一个可排序或者可制定查找规则的对象容器（或称之为集合、数组） 中，通过一个参数，按照某种特定排序或查找方式，将特定的位置的对象反回或修改其值。……说的自己都晕。好，废话少说，我们来看看具体应用。

　　其实大家不用太过在意语法，只需要知道方法签名的含义，即传入什么参数，返回什么值就可以了。

 　  下面我们来试一试自定义索引器： 

using System;
using System.Collections;
using System.Collections.Generic;

namespace IndexerEG
{
    public class Program
    {
        public static void Main(string[] args)
        {
            Test test = new Test();
            Console.WriteLine(test[1]); // 通过索引器得到一个值并输出
            test[1] = "John";   // 通过索引器改变一个值
            Console.WriteLine(test[1]); // 再次输出
            Console.ReadKey();
            // 输出 Johness2
　　　　　　  // John
        }
    }

    public class Test
    {
        // 定义用于实验的字符串数组
        string[] testStrings = { "Johness1", "Johness2", "Johness3", "Johness4", "Johness5" };
        // 定义索引器
        public string this[int index]
        {
            get
            {
                return testStrings[index];
            }
            set
            {
                testStrings[index] = value;
            }
        }
    }
}

　　在索引器的方法体内（姑且这样说吧），set和get不是必须都有的，但声明了之后就必须有方法体，当然，也就是要有大括号……

　　一个类中只能声明一个索引器（这仅仅是相对于入参而言），只是相对于父类继承的索引器需要有一点注意：

using System;
using System.Collections;
using System.Collections.Generic;

namespace IndexerEG
{
    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" };
        
        // 一个类中可以定义多个索引器
　　　　 // 可以理解为索引器的重载
　　　　 // 只要入参类型不同即可（所有索引器的入参集合中）
　　　　 // 这意味着您若添加以下代码也能通过编译并运行正常
　　　　 // 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]; }
        }
    }
}

　　关于索引器的就是这些，索引器是类的特殊成员，也拥有类似访问器的set和get，它可以重载，可以从父类继承。它无法访问静态成员。

　　严格来说，一个类只有一个索引器，所谓重载只是改变入参和出参的类型，切记：出参类型可以重复，但入参不行（在整个类中）。除非是该类实例成员与其父类所继承所拥有的。

　　下面，我们将简要地分析C#里的运算符，并探讨自定义运算符的可行性与应用。

　　我们先从系统API中观察运算符的些许特点： 

// 摘要:
//     将指定的日期和时间与另一个指定的日期和时间相减，返回一个时间间隔。
//
// 参数:
//   d1:
//     System.DateTime（被减数）。
//
//   d2:
//     System.DateTime（减数）。
//
// 返回结果:
//     System.TimeSpan，它是 d1 和 d2 之间的时间间隔，即 d1 减去 d2。
        [TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
        public static TimeSpan operator -(DateTime d1, DateTime d2);
        public static DateTime operator -(DateTime d, TimeSpan t);
        public static bool operator !=(DateTime d1, DateTime d2);
        public static DateTime operator +(DateTime d, TimeSpan t);
        public static bool operator <(DateTime t1, DateTime t2);
        public static bool operator ==(DateTime d1, DateTime d2);
        public static bool operator >(DateTime t1, DateTime t2);
        public static bool operator >=(DateTime t1, DateTime t2);

　　以上是系统API中自带运算符的方法签名（部分注释省略），出处为System.DateTime；

　　看得出，以上代码就是方法原型。运算符相当于方法名，前面的是关键字作为限定和声明，它也有入参和出参。入参是括号中的两个值，使用时在该运算符的一前一后，出参当然就是operator关键字前面的了，在使用时通过整体的返回值获得出参。

　　下面我们通过自定义运算符来详细了解，并提出和解决问题：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace OperatorEG
{
    class Program
    {
        static void Main(string[] args)
        {
            Test1 test1 = new Test1();
            Test1 test2 = new Test1();
            Console.WriteLine(test1 == test2);  // 使用运算符操作
            Console.WriteLine(test1 != test2);  // 使用运算符操作
            Console.ReadKey();
            // 输出 True
18　　　　　　　 // False
            Console.WriteLine(test1.MyProperty);
        }
    }

    class Test1
    {
        public int MyProperty { get; set; }
        // 在编译之后会有以下警告，通常，他们不会造成不良影响
　　　　 // 警告    “OperatorEG.test”定义运算符 == 或运算符 !=，但不重写 Object.Equals(object o)
　　　　 // 警告    “OperatorEG.test”定义运算符 == 或运算符 !=，但不重写 Object.GetHashCode()    
        public static bool operator !=(Test1 current, Test1 other) { return false; }
        public static bool operator ==(Test1 current, Test1 other) { return true; }
        // 如果==和!=没有成对出现，会报出异常
　　　　 // 比如将!=运算符去除
　　　　 // 则会出现以下错误
　　　　 // 错误    运算符“OperatorEG.test.operator ==(OperatorEG.test, OperatorEG.test)”要求也要定义匹配的运算符“!=”
　　　　 // >和<运算符也必须成对出现
　　　　 // >=和<=也是如此
　　　　 // -和+不需要
    }
}

　　在一系列自定义运算符的操作中，编译器告诉我们：运算符必须是public以及static的。有一些运算符是不能重载的，如+=……

　　由于笔者技术有限请大家参见http://msdn.microsoft.com/zh-cn/library/8edha89s.aspx（可重载运算符（C# 编程指南））

　　http://msdn.microsoft.com/zh-cn/library/6fbs5e2h.aspx（如何：使用运算符重载创建复数类（C# 编程指南））

　　http://msdn.microsoft.com/zh-cn/library/s53ehcz3.aspx（运算符（C# 参考））

　　http://msdn.microsoft.com/zh-cn/library/6a71f45d.aspx（C# 运算符）

　　不过我的资料基本来自自己的经验，我能告诉朋友们的还有：一元运算符采用一个参数，二元运算符需采用两个参数，一般情况下，其中之一须是包含类型。 

　　先贴图一张：

　　

　　

　　以上图片信息来自网络。

　　 我们再看一个有意思的东西：

using System;

namespace OperatorEG
{
    class Test2
    {
        public static bool operator ==(Test2 str1,string str2) { return false; }
        public static bool operator !=(Test2 str1, string str2) { return true; }
        public static bool operator !=(Test2 str1, Test2 str2) { return true; }
        public static bool operator ==(Test2 str1, Test2 str2) { return true; }
    }
}

　　以上代码是无措的（至少是编译时）。

　　当然，在绚丽的技术如果我们不能运用或者不能掌握，也是枉然。那么，运算符的自定义重载对我们编程有什么帮助吗？或者，我们可以在什么时候运用呢？  

　　首先应该说明的是：自定义运算符重载是不被推荐的。

　　而具体的应用我现在还不能举出比较好的例子，不过听说过可能的应用：在数据表中的姓名字段上加上++运算符直接拿到下一条数据……朋友们可以自由发挥啊！