C#中的自定义类型转换

1. using System;
2. using System.Collections.Generic;
3. using System.Text;
5. //用户自定义转换
6. //所有的用户自定义转换都是静态的，要使用static关键字
7. //用户自定义转换分显示和隐示，它们用implicit（隐式转换）或 explicit（显示转换）关键字声明。
8. //static 访问修辞符 转换修辞符 operator 转换类型(参数)
9. namespace CountStrDemo
10. {
11.     class 自定义类型转换
12.     {
13.         //public static void Main(string[] args)
14.         //{
15.         //    MyCaseDemo obj = new MyCaseDemo( 5 , 8 );
16.         //    //隐式转换
17.         //    float f = obj;
18.         //    Console.WriteLine( f.ToString() );
19.         //    //显式转换
21.         //    int i = (int)obj;
22.         //    Console.WriteLine( i.ToString() );
23.         //    Console.Read();
24.         //}
26.         class MyCaseDemo
27.         {
28.             public int x;
29.             public int y;
31.             public MyCaseDemo(int x, int y)
32.             {
33.                 this.x = x;
34.                 this.y = y;
35.             }
37.             // 与运算重载差区别, operator后跟着的是要转成的类型,不是符号.同时也是本方法的返回类型  
38.             //还及是必须用implicit（隐式转换）或 explicit（显示转换）关键字声明。
39.             public static implicit operator float(MyCaseDemo obj)
40.             {
41.                 return obj.y * obj.x;  
42.             }
44.             public static explicit operator int ( MyCaseDemo obj )
45.             {
46.                 return obj.y + obj.x;
47.             }
48.         }
49.     }
50. }
51. 1. using System;
    2. using System.Collections.Generic;
    3. using System.Text;
    5. namespace CountStrDemo
    6. {
    7.     class 类与类的自定义转换
    8.     {
    9.         public static void Main(string[] args)
    10.         {
    11.             C c = new C();
    12.             D d = c;
    13.             Console.WriteLine( d.name );
    14.             Console.Read();
    15.         }
    16.     }
    18.     class B
    19.     { 
    20.     }
    22.     class C : B
    23.     {
    24.         public string name = "c name";
    26.         public static implicit operator D(C c)
    27.         { 
    28.             D d = new D() ;
    29.             d.name = c.name + "让人给搞了";
    30.             return d;
    31.         }
    32.     }
    34.     class D : B
    35.     {
    36.         public string name = "d name";
    38.     }
    39. }
    40. // 类与类之前的转换,不能转换两个直接或者简介继承的关系的类,
    41. //在上例中 C->B D-B都是不对的,唯一的关系只有C->D或者D-C,但是,不可以在CD两类中都定义转换,否则会让编译器搞不清