类型转换有两种，隐式转换和显示转换，当没有数据丢失的时候，隐式转换会自动进行。C#允许用户定义自己的数据类型（结构和类），那么在他们之间的类型转换需要用户自己定义。

C#中基本类型转换：点击打开链接

1、类型转换定义：public  static  implicit / explicit  operator  type1（type2   para）{ return  }

注意：

（1）、与运算符重载类似，使用 public 和 static ，表示与类相关的公有操作，使用 operator 关键字；

（2）、implicit 表示隐式转换，explicit 表示显示转换，遵循的原则与预定义的类型转换一致，当没有数据丢失的时候使用 implicit ，否则使用 explicit ；

（3）、type1 表示 目标类型，type2 表示 源类型，需要用 return 返回 type1 类型对象。

下面给出自定义类与值类型的转换定义：

// 自定义的一个类
public class MyClass1
{
    // uint 类型字段 a
    public uint a;
    // int 类型字段 b
    public int b;
    // 自定义构造函数
    public MyClass1(uint a,int b)
    {
        this.a = a;
        this.b = b;
    }
    // 自定义的显示转换：将 MyClass1 类型的对象转换成 int 类型
    public static explicit operator int(MyClass1 obj)
    {
        // 实际上是将 字段 a 的值通过基本类型的强制转换，变成 int 类型的返回值
        return (int)obj.a;
    } 
    // 自定义的隐式转换: 将 MyClass1 类型的对象转换成 float 类型
    public static implicit operator float(MyClass1 obj)
    {   // 实际上是将 字段 b 的值转换成float，因为 int 转 float 是隐式的，所以定义的时候可以定义为 implicit
        return obj.b;
    } 
}

// 声明并初始化 MyClass1 类的对象
MyClass1  myClass = new MyClass1(1,11);
// 调用自定义的显示转换
int a = (int)myClass; // a = 1
// 调用自定义的隐式转换 
float b = myClass; // b = 11

2、类之间自定义类型转换

当两个类之间没有派生关系时（有派生关系时，转换已经存在），可以在源类型或者是派生类型中定义类型转换。

注意：

（1）、两个类之间没有派生关系时才可以自定义类型转换；

（2）、类型转换在源类型或目标类型中定义，可以分开定义，但是两个类中不能定义相同的类型转换。

下面给出示例：

1.   // 自定义的类 MyClassA
2.   public class MyClassA
3.   {
4.   // 如果 MyClassB 中没有这个与这个相同的转换，这里可以给出
5.   // public static explicit operator MyClassB(MyClassA obj)
6.   // {
7.   // return new MyClassB();
8.   // }
9.   }
10.   // 自定义的类 MyClassB
11.   public class MyClassB
12.   {
13.   // 定义的显示类型转换,返回一个 MyClassA 类型的对象
14.   public static explicit operator MyClassA(MyClassB obj)
15.   {
16.   return new MyClassA();
17.   }
18.    
19.   // 定义的显示类型转换,返回一个 MyClassB 类型的对象
20.   public static explicit operator MyClassB(MyClassA obj)
21.   {
22.   return new MyClassB();
23.   }
24.   }

1.   // 声明并初始化一个 MyClassB 类对象
2.   MyClassB myClassB = new MyClassB();
3.   // 使用 强制类型转换
4.   MyClassA myClassA = (MyClassA)myClassB;
5.   MyClassB myClassB1 = (MyClassB)myClassA;

注意：派生类可以隐式转换成基类。基类转换成派生类时，只有基类引用指向该派生类对象时可以转换成功，其他的会抛出异常。

下面给出示例：

1.   // 基类
2.   public class MyBase
3.   {
4.    
5.   }
6.   public class MySub1:MyBase
7.   {
8.    
9.   }
10.   public class MySub2:MyBase
11.   {
12.    
13.   }

1.   // 基类的引用指向基类的对象
2.   MyBase myBase = new MyBase();
3.   // MySub1 类型的对象隐式转换成了 MyBase 类型
4.   MyBase myBase1 = new MySub1();
5.   // MySub2 类型的对象隐式转换成了 MyBase 类型
6.   MyBase myBase2 = new MySub2();
7.   // 因为 MyBase 引用的是本类的对象，执行的时候会抛出异常
8.   MySub1 mySubA = (MySub1)myBase;
9.   // 可以执行
10.   MySub1 mySubA1 = (MySub1)myBase1;
11.   // 因为 MyBase 引用的是 MySub2 类型的对象，执行的时候会抛出异常
12.   MySub1 mySubA2 = (MySub1)myBase2;

==