运算符和类型强制转换
1.运算符
运算符的简化操作
条件运算符：
if-else的简化操作，也称三元运算符。如果条件为真，返回一个值，为假返回另外一个值。
condition?true_value:false_value
checked和unchecked运算符：
如果把一个代码块标记为checked,CLR会执行溢出检查，如果溢出，会抛出OverflowException异常,运行以下代码会抛出异常。
byte b=;
checked
{
b++;
}
Console.WriteLine(b.ToString());
如果要禁止溢出检查，将checked改为unchecked
unchecked是默认行为，只有在需要把几行未检查的代码放在一个显式地标记为checked的大代码块中，才需要显式使用unchecked
byte b=;
unchecked
{
b++;
}
Console.WriteLine(b.ToString());
is运算符:
is运算符可以检查对象是否与特定的类型兼容。“兼容”表示对象是否该类型，或者派生自该类型
int i=;
if(i is object)
{
Console.WriteLine("i is an object");
}
as运算符：
as运算符执行引用类型的显式转换。如果转换的类型与指定的类型兼容，则转换成功，否则返回null
object o1="Some String";
object o2=; string s1=o1 as string;//s1="Some String"
string s2=o2 as string;//s2=null
sizeof运算符
使用sizeof运算符可以确定栈中值类型需要的长度(单位：字节)
Console.WriteLine(sizeof(int));
如果对复杂类型(非基本类型)使用sizeof运算符，就需要把代码放在unsafe块中
unsafe
{
Console.WriteLine(sizeof(int));
}
typeof运算符：
typeof运算符返回一个特定类型的Type对象,typeof(string)返回一个String类型的Type对象。
可空运算符?和运算符：
对于布尔类型，可以给它指定true或false值。但是要把该类型的值定义为undefined;这时候就可以使用可空类型，考虑null值和各种运算符一起使用的影响。
int? a= null;
int? b= a + ;//b=null
int? c = a * ;//c=null
空合并运算符??：
可以处理可空类型和引用类型时表示null可能的值。这个运算符放在两个操作数之间。第一个操作数必须是可空类型或引用类型。第二个操作数必须与第一个操作数类型相同，或者可以隐含地转换为第一个操作数的类型。空合并运算符的计算如下：
1.如果第一个操作数不是null,整个表达式就等于第一个操作数的值。
2.如果第一个操作数是null,整个表达式就等于第二个操作数的值。
如果a是null默认等于10；如果不是null;a就是3;
int? a = null;
int b; b = a ?? ;//b has the value 10
a = ;
b = a ?? ;//b has the value 3
运算符的优先级
3.类型的安全性
我们需要把一种类型转换为需要的另一种类型。
类型转换
byte value1 = ;
byte value2 = ;
byte total;
total = value1 + value2;
Console.WriteLine(total);
在试图编译这些代码时，会得到错误信息
Cannot implicitly convert type 'int' to 'type'
隐式转换：
只要值没有发生改变。类型转换就可以自动(隐式)进行
byte value1 = ;
byte value2 = ;
long total;
total = value1 + value2;
Console.WriteLine(total);
当2个byte类型相加时，实际上和的值已经变成long类型了，这时候不需要任何的类型强制转换。
C#支持的隐式类型转换
可空类型不能隐式的转换为非可空类型。必须通过显式转换。
不能进行显式转换的情况：
装箱和拆箱
装箱和拆箱是值类型和引用类型之间相互转换是要执行的操作。
1. 装箱在值类型向引用类型转换时发生
2. 拆箱在引用类型向值类型转换时发生
拆箱操作的执行过程和装箱操作过程正好相反，是将存储在堆上的引用类型值转换为值类型并给值类型变量。
int myIntNumber = ;
object myObject = myIntNumber;
int的基类是object类型,因为所有类型都继承自object类；子类转父类是隐式转换。父类转子类是显式转换。
object number = ;
int sum = (int)number + ;
4.比较对象的相等性
比较引用类型的相等性
RefernceEquals方法
RefernceEquals方法是一个静态方法，测试两个引用是否引用类的同一个实例。特别是两个引用是否包含内存中相同地址。方法不能重写。如果提供的两个引用是引用同一个对象实例。则返回true,否则返回false
SomeClass x, y;
x = new SomeClass();
y = new SomeClass();
bool B1 = ReferenceEquals(null, null);//true
bool B2 = ReferenceEquals(null, x);//false
bool B3 = ReferenceEquals(x, y);//true
虚拟的Equals方法
静态的Equals方法
比较运算符(==):
比较运算符只做值进行比较，不做引用比较。
比较值类型的相等性
5.运算符重载
您可以重定义或重载 C# 中内置的运算符。因此，程序员也可以使用用户自定义类型的运算符。重载运算符是具有特殊名称的函数，是通过关键字 operator 后跟运算符的符号来定义的。与其他函数一样，重载运算符有返回类型和参数列表。
例如，请看下面的函数：
public static Box operator+ (Box b, Box c)
{
Box box = new Box();
box.length = b.length + c.length;
box.breadth = b.breadth + c.breadth;
box.height = b.height + c.height;
return box;
}
上面的函数为用户自定义的类 Box 实现了加法运算符（+）。它把两个 Box 对象的属性相加，并返回相加后的 Box 对象。
运算符重载的实现
下面的程序演示了完整的实现：
using System; namespace OperatorOvlApplication
{
class Box
{
private double length; // 长度
private double breadth; // 宽度
private double height; // 高度 public double getVolume()
{
return length * breadth * height;
}
public void setLength( double len )
{
length = len;
} public void setBreadth( double bre )
{
breadth = bre;
} public void setHeight( double hei )
{
height = hei;
}
// 重载 + 运算符来把两个 Box 对象相加
public static Box operator+ (Box b, Box c)
{
Box box = new Box();
box.length = b.length + c.length;
box.breadth = b.breadth + c.breadth;
box.height = b.height + c.height;
return box;
} } class Tester
{
static void Main(string[] args)
{
Box Box1 = new Box(); // 声明 Box1，类型为 Box
Box Box2 = new Box(); // 声明 Box2，类型为 Box
Box Box3 = new Box(); // 声明 Box3，类型为 Box
double volume = 0.0; // 体积 // Box1 详述
Box1.setLength(6.0);
Box1.setBreadth(7.0);
Box1.setHeight(5.0); // Box2 详述
Box2.setLength(12.0);
Box2.setBreadth(13.0);
Box2.setHeight(10.0); // Box1 的体积
volume = Box1.getVolume();
Console.WriteLine("Box1 的体积： {0}", volume); // Box2 的体积
volume = Box2.getVolume();
Console.WriteLine("Box2 的体积： {0}", volume); // 把两个对象相加
Box3 = Box1 + Box2; // Box3 的体积
volume = Box3.getVolume();
Console.WriteLine("Box3 的体积： {0}", volume);
Console.ReadKey();
}
}
}
当上面的代码被编译和执行时，它会产生下列结果：
Box1 的体积：
Box2 的体积：
Box3 的体积：
下表描述了 C# 中运算符重载的能力：
6.用户定义的类型强制转换
实现用户定义的类型强制转换
在这个示例中，定义一个结构Currency,包含一个正的USD($)金额，C#为次提供了decimal类型，但如果需要进行复杂的财务处理。可以编写自己的结构和类来表示相应的金额。在这样的类上实现特定的方法。
struct Currency
{
public uint Dollars;
public ushort Cents; public Currency(uint dollars, ushort cents)
{
Dollars = dollars;
Cents = cents;
} public override string ToString()
{
return string.Format("${0}.{1,-2:00}", Dollars, Cents);
} public static implicit operator float(Currency value)
{
return value.Dollars + (value.Cents / 100.05f);
}
}
static void Main(string[] args)
{ Currency balance = new UnitTestProject1.Currency(, );
float f = balance;
}
如果将float类型给balance则不能进行转换。
float f = 10.5f;
Currency balance = new UnitTestProject1.Currency(, );
balance = f;
然后我们在Currency类再添加一个方法
public static explicit operator Currency(float value)
{
uint dollbars = (uint)value;
ushort cents = (ushort)((value-dollbars)*);
return new Currency(dollbars, cents);
}
下面代码会正常运行
Currency balance = new Currency(, ); Console.WriteLine(balance);
Console.WriteLine("balance is " + balance);
Console.WriteLine("balance is(using ToString()) " + balance.ToString());
float balance2 = balance;
Console.WriteLine("After converting to float,=" + balance2);
balance = (Currency)balance2;
Console.WriteLine("After converting back to Currency,=" + balance);
Console.WriteLine("Now attempt to convert out of range value of " + "-$50.50 to aCurrency:");
checked
{
balance = (Currency)(50.50);
Console.WriteLine("Result is " + balance.ToString());
}
类之间类型强制转换：
如果某个类派生自另一个类，就不能定义两个类之间的类型强制转换。
类型强制转换必须在源数据类型或目标数类型的内部定义。
基类与派生类之间强制转换：
派生类实现了基类，基类转为派生类，这种情况是可以转换成功的
基类转派生类，这种情况是不能转换成功的。
MyBase derivedObject=new MyDerived();
MyBase baseObject=new MyBase();
MyDerived derivedCopy1=(MyDerived)derivedObject; //ok
MyDerived derivedCopy2=(MyDerived)baseObject;//Throws Exception
装箱与拆箱之间强制转换：
从基本类型到object类型是一种隐式的强制转换。因为这种强制转换是从派生类到基类的转换。
Currency balance=new Currency(,);
object baseCopy=balance;
对于基类的子类实现。由基类转换为子类。需要显示的强制转换。
object derivedObject=new Currency(,)
object baseObject=new object();
Currency derivedCopy1=(Currency)derivedObject;//ok
Currency derivedCopy2=(Currency)baseObject;//Exception
多重类型的强制转换
如果方法调用带有多个重载方法，并要给该方法传递参数。而该参数的数据类型不匹配任何重载方法，就可以迫使编译器确定使用哪些强制转换方式进行数据转换，从而决定使用哪个重载方法(并进行相应的数据转换)