再读MSDN的重载运算符
MSDN就是微软开发的官方指南了，里面都是对开发中应用到的基本知识作很精辟的讲解，这一篇读读可重载的运算符。
C# 允许用户定义的类型通过使用 operator 关键字定义静态成员函数来重载运算符。但不是所有的运算符都可被重载，下表列出了不能被重载的运算符：
|
运算符 |
可重载性 | ||
|
可以重载这些一元运算符。 | |||
|
可以重载这些二进制运算符。 | |||
|
比较运算符可以重载（但请参见本表后面的说明）。 | |||
|
条件逻辑运算符不能重载，但可使用能够重载的 & 和 | 进行计算。 | |||
|
不能重载数组索引运算符，但可定义索引器。 | |||
|
赋值运算符不能重载，但 += 可使用 + 计算，等等。 | |||
|
不能重载这些运算符。 | |||
|
注意 | |||
|
比较运算符（如果重载）必须成对重载；也就是说，如果重载 ==，也必须重载 !=。反之亦然，< 和 > 以及 <= 和 >= 同样如此。 |
若要在自定义类中重载运算符，您需要在该类中创建具有正确签名的方法。该方法必须命名为“operator X”，其中 X 是正在重载的运算符的名称或符号。一元运算符具有一个参数，二元运算符具有两个参数。在每种情况下，参数的类型必须与声明该运算符的类或结构的类型相同，如下面的示例所示：
public static Complex operator +(Complex c1, Complex c2)
C# 允许程序员在类或结构上声明转换，以便类或结构与其他类或结构或者基本类型进行相互转换。转换的定义方法类似于运算符，并根据它们所转换到的类型命名。要转换的类型参数或转换结果的类型必须是（不能两者同时都是）包含类型。
代码
class SampleClass
{
public static explicit operator SampleClass(int i)
{
SampleClass temp = new SampleClass();
// code to convert from int to SampleClass...
return temp;
}
}
class SampleClass
{
public static explicit operator SampleClass(int i)
{
SampleClass temp = new SampleClass();
// code to convert from int to SampleClass...
return temp;
}
}
------------------------------------------------
struct Digit
{
byte value;
public Digit(byte value) //constructor
{
if (value > 9)
{
throw new System.ArgumentException();
}
this.value = value;
}
public static explicit operator Digit(byte b) // explicit byte to digit conversion operator
{
Digit d = new Digit(b); // explicit conversion
System.Console.WriteLine("conversion occurred");
return d;
}
}
class TestExplicitConversion
{
static void Main()
{
try
{
byte b = 3;
Digit d = (Digit)b; // explicit conversion
}
catch (System.Exception e)
{
System.Console.WriteLine("{0} Exception caught.", e);
}
}
}
struct Digit
{
byte value;
public Digit(byte value) //constructor
{
if (value > 9)
{
throw new System.ArgumentException();
}
this.value = value;
}
public static implicit operator byte(Digit d) // implicit digit to byte conversion operator
{
System.Console.WriteLine("conversion occurred");
return d.value; // implicit conversion
}
}
class TestImplicitConversion
{
static void Main()
{
Digit d = new Digit(3);
byte b = d; // implicit conversion -- no cast needed
}
}
struct RomanNumeral
{
private int value;
public RomanNumeral(int value) //constructor
{
this.value = value;
}
static public implicit operator RomanNumeral(int value)
{
return new RomanNumeral(value);
}
static public implicit operator RomanNumeral(BinaryNumeral binary)
{
return new RomanNumeral((int)binary);
}
static public explicit operator int(RomanNumeral roman)
{
return roman.value;
}
static public implicit operator string(RomanNumeral roman)
{
return ("Conversion not yet implemented");
}
}
struct BinaryNumeral
{
private int value;
public BinaryNumeral(int value) //constructor
{
this.value = value;
}
static public implicit operator BinaryNumeral(int value)
{
return new BinaryNumeral(value);
}
static public explicit operator int(BinaryNumeral binary)
{
return (binary.value);
}
static public implicit operator string(BinaryNumeral binary)
{
return ("Conversion not yet implemented");
}
}
class TestConversions
{
static void Main()
{
RomanNumeral roman;
BinaryNumeral binary;
roman = 10;
// Perform a conversion from a RomanNumeral to a BinaryNumeral:
binary = (BinaryNumeral)(int)roman;
// Perform a conversion from a BinaryNumeral to a RomanNumeral:
// No cast is required:
roman = binary;
System.Console.WriteLine((int)binary);
System.Console.WriteLine(binary);
}
}
来源：https://www.cnblogs.com/gege_s/archive/2010/05/31/1748146.html