C#中的explicit和implicit了解一下吧

今天在研究公司项目框架的时候看到了下面的用法,public static implicit operator JsonData(int data);。貌似很久没用过这种隐士转换的写法了,因此重新温习一下C#中转换相关的知识。

作者:依乐祝
原文地址:https://www.cnblogs.com/yilezhu/p/10898582.html

implicit

implicit 关键字用于声明隐式的用户自定义的类型转换运算符。 如果可以确保转换过程不会造成数据丢失,则可使用该关键字在用户定义类型和其他类型之间进行隐式转换。

使用隐式转换操作符之后,在编译时会跳过异常检查,所以隐式转换运算符应当从不引发异常并且从不丢失信息,否则在运行时会出现一些意想不到的问题。

示例

class Digit
{
    public Digit(double d) { val = d; }
    public double val;
    // ...other members

    // User-defined conversion from Digit to double
    public static implicit operator double(Digit d)
    {
        return d.val;
    }
    //  User-defined conversion from double to Digit
    public static implicit operator Digit(double d)
    {
        return new Digit(d);
    }
}

class Program
{
    static void Main(string[] args)
    {
        Digit dig = new Digit(7);
        //This call invokes the implicit "double" operator
        double num = dig;
        //This call invokes the implicit "Digit" operator
        Digit dig2 = 12;
        Console.WriteLine("num = {0} dig2 = {1}", num, dig2.val);
        Console.ReadLine();
    }
}

隐式转换可以通过消除不必要的强制转换来提高源代码的可读性。 但是,因为隐式转换不需要程序员将一种类型显式强制转换为另一种类型,所以使用隐式转换时必须格外小心,以免出现意外结果。 一般情况下,隐式转换运算符应当从不引发异常并且从不丢失信息,以便可以在程序员不知晓的情况下安全使用它们。 如果转换运算符不能满足那些条件,则应将其标记为 explicit。 有关详细信息,请参阅使用转换运算符

explicit显示转换

explicit 关键字声明必须通过显示的调用用户定义的类型转换运算符来进行转换。

以下示例定义从 Fahrenheit 类转换为 Celsius 类的运算符。 必须在 Fahrenheit 类或 Celsius 类中定义运算符:

public static explicit operator Celsius(Fahrenheit fahr)
{
    return new Celsius((5.0f / 9.0f) * (fahr.Degrees - 32));
}

如下所示,调用用户定义的转换运算符来强制转换:

Fahrenheit fahr = new Fahrenheit(100.0f);
Console.Write($"{fahr.Degrees} Fahrenheit");
Celsius c = (Celsius)fahr;

此转换运算符从源类型转换为目标类型。 源类型提供转换运算符。 不同于隐式转换,显式转换运算符必须通过转换的方式来调用。 如果转换操作会导致异常或丢失信息,则应将其标记为 explicit。 这可阻止编译器静默调用可能产生意外后果的转换操作。

省略转换将导致编译时错误 CS0266。

有关详细信息,请参阅使用转换运算符

示例

下面的示例提供了 FahrenheitCelsius 类,其中每个类均提供转换为其他类的显式转换运算符。

class Celsius
{
    public Celsius(float temp)
    {
        Degrees = temp;
    }

    public float Degrees { get; }

    public static explicit operator Fahrenheit(Celsius c)
    {
        return new Fahrenheit((9.0f / 5.0f) * c.Degrees + 32);
    }
}

class Fahrenheit
{
    public Fahrenheit(float temp)
    {
        Degrees = temp;
    }

    public float Degrees { get; }

    public static explicit operator Celsius(Fahrenheit fahr)
    {
        return new Celsius((5.0f / 9.0f) * (fahr.Degrees - 32));
    }
}

class MainClass
{
    static void Main()
    {
        Fahrenheit fahr = new Fahrenheit(100.0f);
        Console.Write($"{fahr.Degrees} Fahrenheit");
        Celsius c = (Celsius)fahr;

        Console.Write($" = {c.Degrees} Celsius");
        Fahrenheit fahr2 = (Fahrenheit)c;
        Console.WriteLine($" = {fahr2.Degrees} Fahrenheit");
    }
}
// 输出:
// 100 Fahrenheit = 37.77778 Celsius = 100 Fahrenheit

示例

下面的示例定义结构 Digit,它表示单个的十进制数字。 将运算符定义为从 byteDigit 的转换,但由于并非所有字节都可转换为 Digit,因此该转换应该应用显式转换。

struct Digit
{
    byte value;
    public Digit(byte value)
    {
        if (value > 9)
        {
            throw new ArgumentException();
        }
        this.value = value;
    }

    // 定义从byte到Digit的显示转换 explicit operator:
    public static explicit operator Digit(byte b)
    {
        Digit d = new Digit(b);
        Console.WriteLine("转换已完成");
        return d;
    }
}

class ExplicitTest
{
    static void Main()
    {
        try
        {
            byte b = 3;
            Digit d = (Digit)b; // 显示转换
        }
        catch (Exception e)
        {
            Console.WriteLine("{0} 捕获到一成.", e);
        }
    }
}
/*
输出:
转换已完成
*/

参考资料

原文地址:https://www.cnblogs.com/yilezhu/p/10898582.html

时间: 2024-10-17 00:27:40

C#中的explicit和implicit了解一下吧的相关文章

C#中的Explicit和Implicit

今天在Review一个老项目的时候,看到一段奇怪的代码. if (dto.Payment == null) continue; var entity = entries.FirstOrDefault(e => e.LedgerEntryID == dto.LedgerEntryID); dto.Payment = entity?.Payment; 其中dto.Payment是一个PaymentDTO类的实例,entity?.Payment是一个Payment类的实例,PaymentDTO类和Pa

operator、explicit与implicit

说这个之前先说下什么叫隐式转换和显示转换 1.所谓隐式转换,就是系统默认的转换,其本质是小存储容量数据类型自动转换为大存储容量数据类型. 例如:float f = 1.0: double d=f:这样就是把float类型的f隐式转换成double类型了!但其实系统帮我们做了类似如下的工作: float f = 1.0: double d=(double)f: 对于表示数值的基本数据类型来说,数值范围小的数据类型转换成数值范围大的数据类型可以进行隐式转换,而反过来则必须进行显示转换 2.显式类型转

深入理解C++中的explicit关键字

深入理解C++中的explicit关键字 [email protected] http://blog.csdn.net/kezunhai C++中的explicit关键字只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的, 跟它相对应的另一个关键字是implicit, 意思是隐藏的,类构造函数默认情况下即声明为implicit(隐式). 关于explicit关键字,先看看MSDN上的解释: This keyword is a declaration speci

C++中的explicit关键字的用法

一.explicit作用: 在C++中,explicit关键字用来修饰类的构造函数,被修饰的构造函数的类,不能发生相应的隐式类型转换,只能以显示的方式进行类型转换. 二.explicit使用注意事项: explicit 关键字只能用于类内部的构造函数声明上. explicit 关键字作用于单个参数的构造函数. 在C++中,explicit关键字用来修饰类的构造函数,被修饰的构造函数的类,不能发生相应的隐式类型转换 参考博客:http://www.cnblogs.com/this-54327365

C#关键字explicit、implicit、operator 、unsafe 、fixed

今天遇到一些一般不常用,但说不定什么情况下就能用到的C#关键字. 转换关键字 explicit 定义强制转换 // Must be defined inside a class called Fahrenheit: public static explicit operator Celsius(Fahrenheit fahr) { return new Celsius((5.0f / 9.0f) * (fahr.degrees - 32)); } implicit 定义隐性转换 // User-

类型转换关键字explicit与implicit的用法

这篇是个语法文,虽然这两个关键字比较陌生,但让自己有个印象不是坏事 explicit 明确转换与 implicit 隐含转换都是c#内的关键字,目的是让一个类型 转换到另外一个类型,最常见的例子就是由double转换到int时要使用明确转换, 而int转换到double的时候是使用隐含转换. double d = default(double); int i = default(int); //double 转换为 int 时必须明确定义类型 //否则编译器会丢出错误 i = (int)d; /

C# 参考之转换关键字:operator、explicit与implicit

operator operator 关键字用于在类或结构声明中声明运算符.运算符声明可以采用下列四种形式之一: public static result-type operator unary-operator ( op-type operand ) public static result-type operator binary-operator ( op-type operand, op-type2 operand2 ) public static implicit operator co

DbContext 中的 Explicit interface implementation

疑惑 前段时间一直再用Entity Framework 6,写了一些公用的方法,在这个过程中发现了DbContext实现的接口IObjectContextAdapter,可以通过这个接口访问到更底层的ObjectContext对象,比如 ((IObjectContextAdapter)ctx).ObjectContext 当时就觉得很奇怪,为什么不能直接获取,而需要一次转换,主要是奇怪C#是通过什么形式把ObjectContext给hide住的,不过当时也没多想,忙于完成工作.最近比较系统的再过

C++中的explicit关键字介绍

C++中的关键字explicit主要是用来修饰类的构造函数,被修饰的构造函数的类,不能发生相应的隐式类型转换,只能以显示的方式进行类型转换.类构造函数默认情况下声明为隐式的即implicit. 隐式转换即是可以由单个实参来调用的构造函数定义了一个从形参类型到该类类型的隐式转换.编译器在试图编译某一条语句时,如果某一函数的参数类型不匹配,编译器就会尝试进行隐式转换,如果隐式转换后能正确编译,编译器就会继续执行编译过程,否则报错. explicit关键字只能用于类内部的构造函数声明上,而不能用在类外