C#重载运算符详解

本文较为详细的描述了重载运算符的方法。一般来说，重载运算符在实际的项目开发中会经常的用到，但如果某些自定义类型通过简短几行代码重载一些常用的运算符（如：+-*/），就能让编程工作带来方便；重载运算符就是告诉编译器+-*/等运算符对于自定义类型进行什么样的操作，在代码中需要注意几点。

一、尽可能的不要改变运算符本身的含义

二、所有的运算符重载都必须声明为public和static

三、不同于扩展方法，所重载的方法必须是在被重载的类型内部，且用关键字operator

C#中的两个字符串相加，实际上是连接两个字符串，假如有两个EmployeeDetail类型相加得到一个EmployeeCollection集合，如：

EmployeeDetail a,b;

....

EmployeeCollection collection = a+b;

当编译器遇到上面的代码时就会自动调用EmployeeDetail类上标有operator +的静态方法，并将两个操作数a和b作为参数传递给对于的方法，该方法需要方法一个值赋给collection，假设EmployeeDetail类有三个属性分别是FirstName,MiddleName,LastName，还重写了ToString方法返回一个连接这三个名称的字符串，代码如：

[Serializable]
public class EmployeeDetail
{
  public string FirstName { get; set; }
  public string MiddleName { get; set; }
  public string LastName { set;get; }
  public override string ToString()
  {
    return string.Format("{0}{1}{2}{3}{4}", FirstName, string.IsNullOrWhiteSpace(MiddleName) ? null : "."
      , MiddleName
      , string.IsNullOrWhiteSpace(LastName) ? null : ".",
      LastName).Trim();
  }
}

下面的代码为“+”运算符提供支持的运算符重载：

public static EmployeeCollection operator +(EmployeeDetail a, EmployeeDetail b)
{
 return new EmployeeCollection() { a, b };
}

OK，给EmployeeDetail类加上这样的一个方法之后，我们就可以像下面那个写代码了：

EmployeeCollection collection = new EmployeeDetail(){FirstName="Jackson",LastName="Bruce"} + new EmployeeDetail(){FirstName="Michael",LastName="Jackson"} ;

但是这样还不够完美，假设a，b，c都是EmployeeDetail类型，下面的代码会抛出一个编译错误：

EmployeeCollection collection = a + b + c;

为什么编译不通过呢？大家都知道除了赋值运算符外表达式是从左到右执行的，a+b返回的是EmployeeCollection类型，EmployeeCollection类型并没有重载“+”运算符，编译器不知道要执行什么操作，所以我们还有下面的两个方法：

public static EmployeeCollection operator +(EmployeeCollection collection, EmployeeDetail a)
{
 collection.Add(a);
 return collection;
}
public static EmployeeCollection operator +(EmployeeDetail a, EmployeeCollection collection)
{
 return collection + a;
}

这看起来似乎已经很完美了，但我们还可以做得更好一些，比如要将字符串“Jackson.Bruce”直接隐式转换为EmployeeDetail类型，也就是说可以将“Jackson.Bruce"这种格式的字符串直接赋给EmployeeDetail类型的对象，如：EmployeeDetail employee= “Jackson.Bruce"，那么就需要重载隐式类型转换运算符了，代码如下：

/// <summary>
/// 隐式类型转换
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public static implicit operator EmployeeDetail(string name)
{
/// 其实在这里可以写一个正则表达式检查name的字符串格式是否合法，如果不合法就抛出异常
///
 string[] arr;
 return string.IsNullOrWhiteSpace(name) ? null :
new EmployeeDetail()
{
  FirstName = (arr = name.Trim().Split('.'))[0]
  ,
  LastName = arr.Length > 1 ? arr[arr.Length > 2 ? 2 : 1] : null,
  MiddleName = arr.Length > 2 ? arr[1] : null
};
}
public static EmployeeCollection operator +(EmployeeDetail a, string b)
{
 return new EmployeeCollection() { a, b };
}

看到这里您是不是迫不及待地想试试看，OK写个控制台程序来测试一下：

static void Main(string[] args)
{
 EmployeeDetail employee = "Jackson.Bruce";
 Console.WriteLine("FirstName={0},MiddleNam={1},LastName={2}", employee.FirstName, employee.MiddleName, employee.LastName);
 Console.WriteLine("toString={0}", employee);
 Console.WriteLine();

EmployeeCollection collection = "Michael.Jackson" + employee;

collection += "Bruce.Lee";
 foreach (var e in collection)
 {
Console.WriteLine(e);
 }
 Console.WriteLine();

collection -= employee;

foreach (var e in collection)
 {
Console.WriteLine(e);
 }
 Console.WriteLine("===end===");
 Console.Read();
}

运行结果如下图所示：

全部代码，里面还包含其他运算符的重载，这里就不再介绍了，赶紧动手测试一下吧：

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

namespace 重载运算符
{
 [Serializable]
 public class EmployeeDetail
 {
   public string FirstName { get; set; }
   public string MiddleName { get; set; }
   public string LastName { set;get; }
   public static EmployeeCollection operator +(EmployeeDetail a, EmployeeDetail b)
   {
     return new EmployeeCollection() { a, b };
   }

public static EmployeeCollection operator +(EmployeeCollection collection, EmployeeDetail a)
   {
     collection.Add(a);
     return collection;
   }
   public static EmployeeCollection operator +(EmployeeDetail a, EmployeeCollection collection)
   {
     return collection + a;
   }
   /// <summary>
   /// 隐式类型转换
   /// </summary>
   /// <param name="name"></param>
   /// <returns></returns>
   public static implicit operator EmployeeDetail(string name)
   {
     string[] arr;
     return string.IsNullOrWhiteSpace(name) ? null :
       new EmployeeDetail()
       {
         FirstName = (arr = name.Trim().Split('.'))[0]
         ,
         LastName = arr.Length > 1 ? arr[arr.Length > 2 ? 2 : 1] : null,
         MiddleName = arr.Length > 2 ? arr[1] : null
       };
   }
   public static EmployeeCollection operator +(EmployeeDetail a, string b)
   {
     return new EmployeeCollection() { a, b };
   }
   public override string ToString()
   {
     return string.Format("{0}{1}{2}{3}{4}", FirstName, string.IsNullOrWhiteSpace(MiddleName) ? null : "."
       , MiddleName
       , string.IsNullOrWhiteSpace(LastName) ? null : ".",
       LastName).Trim();
   }
 }
 public class EmployeeCollection : List<EmployeeDetail>
 {
   public static EmployeeCollection operator +(EmployeeCollection a, string b)
   {
     a.Add(b);
     return a;
   }
   public static EmployeeCollection operator +(string b, EmployeeCollection a)
   {
     return a + b;
   }

public static EmployeeCollection operator -(EmployeeCollection a, EmployeeDetail b)
   {
     a.Remove(b);
     return a;
   }
 }

class Program
 {
   static void Main(string[] args)
   {
     EmployeeDetail employee = "Jackson.Bruce";
     Console.WriteLine("FirstName={0},MiddleNam={1},LastName={2}", employee.FirstName, employee.MiddleName, employee.LastName);
     Console.WriteLine("toString={0}", employee);
     Console.WriteLine();

EmployeeCollection collection = "Michael.Jackson" + employee;

collection += "Bruce.Lee";
     foreach (var e in collection)
     {
       Console.WriteLine(e);
     }
     Console.WriteLine();

collection -= employee;

foreach (var e in collection)
     {
       Console.WriteLine(e);
     }

Console.WriteLine("===end===");
     Console.Read();
   }
 }
}