C# 运算符和类型强制转换(6) 持续更新

C#支持的运算符

https://msdn.microsoft.com/zh-cn/library/6a71f45d(v=vs.140).aspx

checked 和 unchecked

byte b = ;

b++;

Console.WriteLine(b);

byte数据类型范围 0~255。递增 b 的值会导致溢出。CLR如何处理这个溢出取决于很多因素，包括编译器选项。

可以使用代码块标记 checked，发生溢出，抛出 OverflowException 异常。

byte b = ;

checked

{

    b++;

}

Console.WriteLine(b);

也可以用 /checked 编译器选项进行编译，就可以检查程序中所有未标记代码中的溢出。

反之 unchecked 不检查溢出，注意 unchecked 是默认行为。

byte b = ;

unchecked

{

    b++;

}

Console.WriteLine(b);

is运算符

检查对象是否是该该类型，或者派生自该类型。

 int value = ;

 Console.WriteLine( (value is int) + "    " + (value is object));

as 运算符

执行引用类型的显示类型转换。如果类型不兼容，返回null。

object str = "Hello";

object value = ;

string str1 = str as string;

string value2 = value as string;

value2 等于 null

sizeof运算符

确定在栈中值类型需要的字节大小。

Console.WriteLine( sizeof(int) );

如果是复杂类型（和非基本类型）使用sizeof运算符，需要放在 unsafe 代码块中。

unsafe

{

    Console.WriteLine(sizeof(Customer));

}

typeof 运算符

返回表示特定类型的 System.Type 对象。如 typeof(string) 返回表示 System.String 类型的Type对象。

可空类型运算符

int? v1 = null;

int? a = v1 + ; // a  = null

空合并运算符

int? v1 = null;

v1 = v1 ?? ;

Console.WriteLine(v1);

运算符优先级

一般情况避免利用运算符优先级来生成正确结果，用圆括号指定运算符执行顺序。

类型安全

中间语言（IL）对代码实现强制实现强类型。

强类型语言在没有强制类型转换前，不允许两种不同类型的变量相互操作。

类型转换

byte byte1 = ;

byte byte2 = ;

byte count = byte1 + byte2;

Console.WriteLine(count);

这里编译时，提示您 byte count 改成 int count。只是因为两个 byte类型相加返回 int 类型，这时就需要类型转换了。

1、隐式转换

只要能保证值不会发生任何变化，类型转换就开自动（隐式）进行。

long count = byte1 + byte2;

2、显示转换类型

byte count =(byte) (byte1 + byte2);

要小心的时候显示转换类型，还要注意防止丢失数据。更不能转换 null 。

如果要字符串转换为 int 时

string str = "";

int i = int.Parse(str);

str = i.ToString();

装箱和拆箱

装箱用于描述把一个值类型转换为引用类型。

拆箱把引用类型转换为值类型。

比较引用类型的相等性

ReferenceEquals

两个版本 Equals

比较运算符（==）

1、ReferenceEquals

ReferenceEquals是一个静态方法，测试两个引用类的同一个实例，判断两个引用是否包含内存中的相同地址。

2、虚函数 Equals

因为是虚函数，所以需要在类中重写它，比较。比较方式可以通过值。如果需要用类的实例用作字典中的键，那么需要重写 Object.GetHashCode() 的方式，注意此方式效率非常低的。

3、静态函数 Equals

有两个参数，如果两个引用实际上引用了某个对象，它就调用虚函数 Equals 实例方法。这表示重写了虚函数 Equals ，也重写了静态版本函数。

4、比较运算符 ==

比较值和比较引用。

ReferenceEquals 用于比较引用，Equals 用于比较值，比较运算符看作一个中间项。ReferenceEquals应用值类型时，总是返回false。因为值类型需要装箱到对象中。

System.ValueType 提供的 Equals 的默认重写版本肯定足以应付绝大多数自定义的结构，但仍可以针对自己的接口再次重写它，以提供性能。

运算符重载

重载不仅仅限于算术运算符。还可以重载比较运算符 ==、< 。等语句 if(a==b) 默认比较引用，对于 string，比较字符串是否相同。

struct Vector

{

    public double x, y, z;

    public Vector(double x, double y, double z)

    {

        this.x = x;

        this.y = y;

        this.z = z;

    }

    public Vector(Vector rhs)

    {

        x = rhs.x;

        y = rhs.y;

        z = rhs.z;

    }

    public override string ToString()

    {

        return x + " " + y + " " + z;

    }

    public static Vector operator +(Vector lhs, Vector rhs)

    {

        Vector result = new Vector(lhs);

        result.x += rhs.x;

        result.y += rhs.y;

        result.z += rhs.z;

        return result;

    }

    public static Vector operator *(Vector lhs, double rhs)

    {

        return new Vector(rhs * lhs.x, rhs * lhs.y, rhs * lhs.z);

    }

}

一般运算符左边参数命名 lhs，运算符右边命名 rhs。

Vector vector1, vector2, vector3;

vector1 = new Vector(4.0, 3.0, 1.0);

vector2 = new Vector(4.0, -3.0, -1.0);

vector3 = vector1 + vector2;

Console.WriteLine(vector3);

与C++语言不同，C#不允许重载 "=" 运算符，但如果重载 "+" 运算符，编译器自动使用 "+" 运算符的重载执行 += 匀速符操作。

比较运算符重载

== 和 !=
> 和 <
>= 和 <=

如果重载了 "=="，就必须重载 "!=" 。另外，比较运算符必须返回布尔类型的值。

重载 "==" 和 "!=" 时，必须重载 System.Object 中继承 Equals 和 GetHashCode 方法，否则会产生一个编译警告。原因是Equals方法实现与"=="运算符相同类型的相等逻辑。

public static bool operator ==(Vector lhs, Vector rhs)

{

    if (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z)

    {

        return true;

    }

    else

    {

        return false;

    }

}

public static bool operator !=(Vector lhs, Vector rhs)

{

    return !(lhs == rhs);

}

public override bool Equals(object obj)

{

    return base.Equals(obj);

}

public override int GetHashCode()

{

    return base.GetHashCode();

}

用户自定义的类型强制重载

c#允许定义自己的数据类型（结构和类），并可以在自定义数据类型之间进行类型强制转换。

public static implicit operator float(Currency value)

{

    return (float) value;

}

这里定义的类型强制转换可以隐式地把Currency型的值转换为float型。

implicit 声明数据类型转换为隐式的，编译器就可以隐式或显式的使用这个转换。

explicit 声明为显式的使用它。

public static explicit operator Celsius(Fahrenheit fahr)

{

    return new Celsius((5.0f / 9.0f) * (fahr.degrees - ));

}

Fahrenheit fahr = new Fahrenheit(100.0f);

Console.Write("{0} Fahrenheit", fahr.Degrees);

Celsius c = (Celsius)fahr;

类型强制转换必须同时声明为 public 和 static。

https://msdn.microsoft.com/zh-cn/library/xhbhezf4.aspx

C++中，类型强制转化针对于类的实例成员。

示例

     struct Currency

     {

        public uint Dollars;

        public ushort Cents;

        public Currency(uint dollars, ushort cents)

        {

           this.Dollars = dollars;

           this.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.0f);

        }

        // 显示转换

        public static explicit operator Currency(float value)

        {

            uint dollars = (uint)value;

            ushort cents = (ushort)((value - dollars) * );

            return new Currency(dollars, cents);

        }

     }

  static void Main(string[] args)

  {

     try

     {

        Currency balance = new Currency(,);

        Console.WriteLine(balance); // 转换为 float

        Console.WriteLine("balance is " + balance);  // 隐式调用 toString

        Console.WriteLine("balance is (using ToString()) " + balance.ToString());  // 显示调用 toString

        float balance2 = balance; // 隐式转为 float

        Console.WriteLine("After converting to float, = " + balance2);

        balance = (Currency) balance2; // 显示转为 Currency

        Console.WriteLine("After converting back to Currency, = " + balance);

        Console.WriteLine("Now attempt to convert out of range value of " +

                          "-$50.50 to a Currency:");

        checked

        {

           balance = (Currency)(-50.50);  // 显示转为 Currency

           Console.WriteLine("Result is " + balance.ToString());

        }

     }

     catch(Exception e)

     {

        Console.WriteLine("Exception occurred: " + e.Message);

     }

     Console.ReadLine();

  }

类型转换的语法对于结构和类一样的。

类之间的类型强制转换

定义不同结构或类的实例之间的类型强制是完全合法，也有限制：

如果某个类派生自另一个类，就不能定义这两个类之间的类型强制转换（因为这些类型转换已存在）。
类型强制必须在源数据类型或目标数据类型的内部定义。

C#要求把类型强制转换的定义放在源类或目标类的内部。因为这样可以防止第三方类型强制转换引入类中。

基类和派生类之间的类型强制转换

MyBase 和 MyDerived。其中 Myderived 直接或间接派生自 MyBase 类。

MyDerived derivedObject = new MyDerived();

MyBase baseCopy = derivedObject;

MyDerived 隐式地强制转换为 MyBase

MyBase derivedObject = new MyDerived();

MyBase baseObject = new MyBase();

MyDerived derivedCopy1 = (MyDerived) derivedObject;  // OK

MyDerived derivedCopy2 = (MyDerived) baseObject;     // Throws exception

基类是不可以强制转为派生类。

装箱和拆箱数据类型强制转换

object derivedObject = new Currency();

object baseObject = new object();

Currency derivedCopy1 = (Currency) derivedObject; // OK

Currency derivedCopy2 = (Currency) baseObject;     // Throws exception

多重类型转换

 Currency balance = new Currency();

 long amount = (long) balance;

 double amountD = balance;

Currency 定义了一个 float 的隐式转换，编译器又知道如何显式地从 float 强制转换为 long。所以 IL代码首先把 balance 转换为 float，在把结果转换 long。类似这样。

long amount = (long) (double)balance;

巴特西