精华内容
下载资源
问答
  • C# 隐式转换

    2019-08-18 08:22:12
    下面几种类型的转换被称之为隐式转换 同一性转换 隐式数值转换 隐式枚举转换 隐式引用转换 包装转换 隐式常数表达式转换 用户自定义隐式转换 隐式转换可以在很多种情况下发生,包括函数子句调用,cast...

     

    下面几种类型的转换被称之为隐式转换 

    • 同一性转换 
    • 隐式数值转换 
    • 隐式枚举转换 
    • 隐式引用转换 
    • 包装转换 
    • 隐式常数表达式转换
    • 用户自定义隐式转换

    隐式转换可以在很多种情况下发生,包括函数子句调用,cast计算表达式和赋值语句。

    预定义的隐式转换总会成功而且不会引发异常,适当合理的用户自定义隐式转换也可以展示出这些 特性。

     

    一. 同一性转换

    同一性转换把任何类型转换为统一的类型。只有在所需转换的实体可以被转换到一种特定的类型时才可以进行同一性转换。

     

    二. 隐式数值转换

    隐式数值转换可以在下面类型中发生:

    • 从 sbyte 到 short, int, long, float, double 或 decimal。

    从 byte 到 short, ushort, int, uint, long, ulong, float, double 或 decimal。

    从 short 到 int, long, float, double 或 decimal。

    从 ushort 到 int, uint, long, ulong, float, double 或 decimal。

    从 int 到 long, float, double 或 decimal。

    从 uint 到 long, ulong, float, double 或 decimal。

    从 long 到 float, double 或 decimal。

    从 ulong 到 float, double 或 decimal。

    从 char到 ushort,int,uint, long, ulong, float, double 或 decimal。

    从 float到 double。

    从 int,uint,long到float以及从long到double类型的转换可能会造成精度的损失,但并不会造成数量上的损失。除此之外的其他隐式数值转换不会损失任何信息。这里不存在转到 char类型的隐式数值转换,也就是说其他的整型数据不会被自动地转换为字符型数据。

     

    三. 隐式枚举转换

    一个隐式枚举转换允许小数-整数实字(decimal-integer-literal)被转换成任意的枚举类型。

     

    四. 隐式引用转换

    隐式 reference转换可以在下面类型之间发生:

    • 从任意 引用类型 到对象 。

    从任意 类类型 S 到任意 类类型 T, 只要 S 是由 T 派生出来的。

    从任意 类类型 S 到任意 接口类型 T, 只要 S 实现 T。

    从任意 接口类型 S 到任意 接口类型 T, 只要 S 是由 T 派生出来的。

    从一个带有元素类型 S 的 数组类型 S 到一个带有元素类型 T 的 数组类型 T,只要下述各项均成立:

    S 和 T 只是元素类型不同。换句话说,S 和 T 有相同的维度。

    SE 和 TE 都是 引用类型 。

    存在从 SE 到 TE 隐式引用转换。

    从任意 数 组类型 到 System.Array。

    从任意 代 表类型 到 System.Delegate。

    从任意 数 组类型 或 代表类型 到 System.Icloneable。

    从 null类型到任意 引用类型 。.

    隐式引用转换指的是在引用类型间肯定可以成功的类型转换,它们是不需要实时检测的。

    引用转换,不管是显式或是隐式的都不会改变被转换对象的引用一致性。换句话说,当引转换发生时,它并未改变被转换对象的数值。

     

    五. 包装转换

    包装转换允许任何数值类型被隐式地转换为类型对象,或者任何由这个数值类型实现的接口类型。 包装一个数值类型的数值包括分配一个对象实例并且将数值类型的数值复制到实例当中。

    包装数值类型的数据的实际过程,可以通过想像一个对那种类型的包装类的实际例子来解释。对于数值类型 T,包装类要按下面定义:

    class T_Box
    {
        T value;
        T_Box(T t)
        {
            value = t;
        }
    }
    

    对于类型 T的数值 v的包装现在由执行表达式 T_Box(v)来代替,并且返回类型为 object的结果实例。这样,语句

    int i = 123;

    object box = i;

    从概念上符合

    int i = 123;

    object box = new int_Box(i);

    如上面的 T_Box 和 int_Box 的包装类型实际不存在,而被包装数据的动态类型实际上并不是一个类类型。作为替代,类型T 的一个被包装的数据有动态类型T,而使用 is 操作符的动态类型检查可以很方便地引用T。例如

    int i = 123; 
    object box = i; 
    if (box is int) {  
       Console.Write("Box contains an int"); 
    }
    

    将在控制台输出字符串 Box contains an int

    包装转换隐式地把被包装的数据进行了备份。这与从引用类型到object类型的转换不同,在那里数据一直引用相同的实例,并被认为几乎不从类型 object派生。例如,给出声明

    struct Point
    {
        public int x, y;
        public Point(int x, int y)
        {
            this.x = x;
            this.y = y;
        }
    }
    

    下面的语句

    Point p = new Point(10, 10);

    object box = p;

    p.x = 20;

    Console.Write(((Point)box).x);

    因为在发生把 p赋值给 box的隐含包装操作时,p被拷贝,所以将在控制台上输出数值 10。如果Point被声明为一个类,因为p和box将引用相同的实例,就会输出20。

    六. 隐式常数表达式转换

            常量表达式的类型可以是以下类型之一:sbyte、byte、short、ushort、int、uint、long、ulong、 char、float、double、decimal、bool、string、枚举类型或空(null)类型。

    隐式常数表达式转换允许下列类型的转换:

    1. 整型常数表达式可以被转换成为 sbyte,byte,short,ushort,uint或者 ulong类型,只有这个整型常数表达式的数值未超出目标类型的取值范围就行。 
    2. 一个 long类型的常数表达式可以被转换成为 ulong类型,只有这个常数表达式的取值非负就行。
    展开全文
  • C#隐式转换

    2012-08-11 19:34:15
    从上面的10条我们可以看出,不存在到char类型的隐式转换,这意味着其它整型值不能自动转换为char类型。这一点我们需要特别注意。   下面的程序给出了隐式数值转换的例子。   程序清单6-1:  using ...

    从sbyte类型到short,int,long,float,double,或decimal类型。
     
    ●从byte类型到short,ushort,int,uint,long,ulong,float,double,或decimal类型。
     
    ●从short类型到int,long,float,double,或decimal类型。
     
    ●从ushort类型到int,uint,long,ulong,float,double,或decimal类型。
     
    ●从int类型到long,float,double,或decimal类型。
     
    ●从uint类型到long,ulong,float,double,或decimal类型。
     
    ●从long类型到float,double,或decimal类型。
     
    ●从ulong类型到float,double,或decimal类型。
     
    ●从char类型到ushort,int,uint,long,ulong,float,double,或decimal类型。
     
    ●从float类型到double类型。
     
    其中,从int,uint,或long到float以及从long到double的转换可能会导致精度下降,但决不会引起数量上的丢失。其它的隐式数值转换则不会有任何信息丢失。
     
    结合我们在数据类型中学习到的值类型的范围,我们可以发现,隐式数值转换实际上就是从低精度的数值类型到高精度的数值类型的转换。
     
    从上面的10条我们可以看出,不存在到char类型的隐式转换,这意味着其它整型值不能自动转换为char类型。这一点我们需要特别注意。
     
    下面的程序给出了隐式数值转换的例子。
     
    程序清单6-1:
     using System;
    class Test
    {
      public static void Main()
      {
        byte x=16;
        Console.WriteLine("x={0}",x);
        ushort y=x;
        Console.WriteLine("y={0}",y);
        y=65535;
        Console.WriteLine("y={0}",y);
        float z=y;
        Console.WriteLine("z={0}",z);
      }
    }
    程序的输出将是:
     
    x=16;
     
    y=16;
     
    y=65535;
     
    z=65535;
     
    如果我们在上面程序中的语句之后再加上一句:
     
    y=y+1;
     
    再重新编译程序时,编译器将会给出一条错误信息:
     
    can not implictly convert type 'int' to type 'ushort'
     
    这说明,从整数类型65536到无符号短整型y不存在隐式转换

    本文来自编程入门网:http://www.bianceng.cn/Programming/csharp/200709/4341.htm

    展开全文
  • C# 隐式转换 显示转换

    千次阅读 2013-12-13 22:06:26
    什么是隐式转换:由编译器进行转换,通常是相似类型但长度不同。(int转double) 什么是显示转换:由程序员控制转换过程,通常只能在某些情况下进行。(double转int) 隐式的转换完全由编译器完成,程序员只需写...


    什么是隐式转换:转换的类型内部有对应implicit operator方法的可进行隐式转换


    什么是显示转换:转换的类内部有对应explicit operator或implicit operator方法的可进行显式转换


    隐式的转换由其内部implicit operator方法转换,程序员只需写value1=value2即可。

    显式的转换由其内部explicit operator方法转换,若没有explicit operator,将使用implicit operator方法。程序员需标明转换类型value1=(value1Type)value2。


    隐式转换方法示例:

        public class Type1
        {
            private int value = 0;
            public Type1(int value)
            {
                this.value = value;
            }
            //隐式的将double类型转为Type1类型
             public static implicit operator Type1(double v)
            {
                return new Type1(Convert.ToInt32(v));
            }
             //隐式的将Type1类型转为double类型
            public static implicit operator  double(Type1 v)
            {
                return Convert.ToDouble(v.value);
            }
        }

    使用时:

               Type1 tt = new Type1(123);
                double dd = tt;
         
                double d=222;
                Type1 t = d;


    显式转换方法示例:

     public class Type1
        {
            private int value = 0;
            public Type1(int value)
            {
                this.value = value;
            }
            //显示的将double类型转为Type1类型
            public static  explicit operator  Type1(double v)
            {
                return new Type1(Convert.ToInt32(v));
            }
            //显示的将Type1类型转为double类型
            public static explicit operator  double(Type1 v)
            {
                return Convert.ToDouble(v.value);
            }
        }

    使用时:

                Type1 tt = new Type1(123);
                double dd =(double) tt;
         
                double d=222;
                Type1 t = (Type1)d;


    注意:

    1.如果上面的Type1只定义了隐式转换方法(implicit operator),当对Type1显式转换时,将调用其隐式转换方法,但相反若只定义了显式转换方法(explicit oprator),直接进行隐式转却无法调用显式转换方法。
    2.在Type1内,相同类型间相同转换方向的显式与隐式转换方法不能同时存在:

    如:不能同时存在

           public static explicit operator double(Type1 v)
            {
                return Convert.ToDouble(v.value);
            }

           public static implicit operator double(Type1 v)
            {
                return Convert.ToDouble(v.value);
            }

    但是却可以同时存在:

           public static explicit operator Type1(double v)//将double显式转换为Type1
            {
                return new Type1(Convert.ToInt32(v));
            }
            public static implicit operator double(Type1 v)//将Type1隐式转换为double
            {
                return Convert.ToDouble(v.value);
            }



    PS:基本类型之间的数据转换有下面几个方法:(以double转int为例):

    double d=123;

    int i=0;

    1.i=Convert.ToInt32(d);

    2.i=Int.Parse(d.ToString());

    3.int.Trypase(d.ToString(),out i);

    4.i=(int)d;


    这四者的区别在于:

    第一种转换参数支持最多,可以支持大部分基本类型:double,bool,string,byte.....

    第二种是属于Int类型自己的转换方法,参数只能是string

    第三种与第二种类似,但是返回值是bool表示转换是否成功。他的特点在于如果转换失败不会抛出异常只会返回false,而第二种则会抛出异常。

    第四种只能是数值类型间的强制类型转换。


    展开全文
  • c# 隐式转换 强制转换

    2015-08-15 11:18:38
    隐式转换:范围小到大
    隐式转换:范围小到大  
    
    int i =0;
    long l =i;
    强制转换:范围从大到小<pre name="code" class="csharp">Class C1{
    }
    Class C2:C1{
    }
    Main{
       C1 c11 = new C1();
       //C2 c22 = (c2)c11;//一般会出错  可以用as
       C2 c22 = c11 as C2;//如果不能转换则返回null
    
    }
    as 只能用于 引用类型 或是 可为null类型。
    展开全文
  • 如果可以确保转换过程不会造成数据丢失,则可使用该关键字在用户定义类型和其他类型之间进行隐式转换。 引用摘自:implicit(C# 参考) 仍以Student求和举例 class Student { /// <summary> /// 语文...
  • 隐式转换: sbyte num0 = 10; int num1 = num0; 显示转换: int num2 = 100; sbyte num3 = (sbyte)num2; 转载于:https://www.cnblogs.com/huangxuQaQ/p/10724436.html
  • C# 隐式转换和显式转换

    千次阅读 2018-01-17 01:55:10
    3、由于 Rect 类 不能隐式转换为 double ,所以使用关键字 implicit 对 Rect 类 自定义 隐式转换 4、返回的类型必须和目标类型一致 或 可以转换为目标类型的类型 5、Rect 类 不能显示转换为 int ,使用关键字 ...
  • System.Objec时C#中所有类型的基类,也就是万类之源。 一、值类型  值类型都继承自System.ValueType(派生自System.Objec),继承自System.ValueType的类型在CLR中具有特殊的行为,值类型变量直接包含它们的值。...
  • 高精度的数据类型转换为低精度的数据类型是显示转换,低精度的转换为高精度的是隐式转换。 温馨提示:不能说强制类型转换是从低精度到高精度。 int a=666;float b=(float)a; 由a到b的转换是低精度到高精度的转换...
  • c#隐式转换显示转换

    千次阅读 2011-01-14 09:54:00
    (1) 隐式转换:一般是低类型向高类型转化,能够保证值不发生变化。 隐式数值转换: 从 sbyte 到 short、int、long、float、double 或 decimal。 从 byte 到 short、ushort、int、uint、long、ulong、float double 或 ...
  • C#隐式转换显式求教

    2013-05-07 18:18:56
    1 [img=https://img-bbs.csdn.net/upload/201305/07/1367921822_78792.jpg][/img] [img=https://img-bbs.csdn.net/upload/201305/07/1367921838_95386.jpg][/img] 2 ... 小白求教大神该如何去解决这个问题
  • 有符号位类型的转换,额外的高位用源表达式的符号位填充。这样就维持了被转换的值的正确符号和大小。 特别注意的是负数的转换,额外的高位用1填充,因为负数的二进制表示是对应正数的二进制取反加1,所以高位用1...
  • 通常我们会把一个对象转化成另一种对象,当然我们这里说的不是对象的多态性。 我们这里说的是把一个对象转化成与另一个与之不相关的对象,其实是通过操作符的重写来完成的,如下: public class Person ...
  • 下面方法属于隐式转换 int i=927; long j=i; 下面属于显示转换 double x=19810927.0112; int y=(int)x; Convert.ToInt32();这种属于显示类型转换
  • 一、隐式转换 隐式转换:数据的类型由编译系统自动转换,不需要人工干预,也可叫做自动类型转换。一般由从存储范围小的类型到存储范围大的类型。 如:short(char)→int→long→float→double 例: int a = 1; long ...
  • 显式转换  隐式转换 需要 不需要声明,   不会造成信息丢失   小----->大 父类转子类 子类转父类
  • C#初识隐式转换

    热门讨论 2017-02-13 21:07:48
    在涉及到参数运算的时候往往会遇到两种数据类型不一致的情况,这时时无法直接进行运算的,如果想要进行运算则需要满足下列条件——系统自动完成类型转换——隐式转换 内容 一、两种类型兼容 例如:int 和...
  • implicit 隐式转换 explicit 显示转换
  • C#类型转换:隐式转换:不需要任何工作,也不需要编写代码。任何类型A,只要取值范围完全包含在类型B的取值范围内,就可以隐式转换为类型B。显示转换:明确要求编译器把数值从一种数据类型转换为另一种数据类型时,...
  • C# 隐式类型转换

    2016-03-02 11:46:00
    如果可以确保转换过程不会造成数据丢失,则可使用该关键字在用户定义类型和其他类型之间进行隐式转换。 class Digit { public Digit(double d) { val = d; } public double val; // ...other mem...
  • c# 无法将类型隐式转换 C#隐式类型数组 (C# Implicitly Typed Arrays) Like implicitly typed variables, we can also declare an array without specifying its type such type of arrays are known as Implicitly...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,537
精华内容 9,814
关键字:

c#隐式转换

c# 订阅