C#中的隐式运算符：如何简化类型转换

public struct Celsius
{
    public Celsius(double value)
    {
        Value = value;
    }

    public double Value { get; }

    // Define an implicit operator from Celsius to Fahrenheit
    public static implicit operator Fahrenheit(Celsius celsius)
    {
        double fahrenheit = celsius.Value * 9 / 5 + 32;
        return new Fahrenheit(fahrenheit);
    }
}

public struct Fahrenheit
{
    public Fahrenheit(double value)
    {
        Value = value;
    }

    public double Value { get; }
}

public class Program
{
    public static void Main()
    {
        // Implicitly convert a Celsius temperature to Fahrenheit
        Celsius celsius = new Celsius(25);
        Fahrenheit fahrenheit = celsius;

        Console.WriteLine(fahrenheit.Value);  // Output: 77
    }
}

在此示例中，我们有一个具有Value属性的Celsius类型。我们在Celsius类型中定义了一个隐式运算符，用于将Celsius值转换为Fahrenheit。当我们为Fahrenheit变量赋值为Celsius时，编译器会自动调用隐式运算符，将温度从摄氏度转换为华氏度。

C#中的隐式运算符允许在适当的时候隐式转换对象，从而大大简化代码。这可以使代码更具可读性，并减少对显式类型转换的需求。但是，请务必谨慎使用隐式运算符，并确保转换是安全和合乎逻辑的。

C#语言中隐式运算符的优缺点

就像我们看到的一切一样，会有优点和缺点。我试图确保我们在我的网站上涵盖的每个主题。在我看来，这是了解事情何时更好或更差的最佳方式。

C#语言中隐式运算符的优点

C#中的隐式运算符在软件开发中提供了多种好处。它们可以简化代码并提高可读性，允许自动类型转换，而无需显式转换或转换方法。这消除了对重复和可能容易出错的代码的需求，使代码库更简洁、更易于理解。

请考虑以下示例，其中我们有一个自定义类型Length，表示我们正在使用的度量单位：

public struct Length
{
    public double Value { get; set; }

    // Implicit conversion from Length to double
    public static implicit operator double(Length length)
    {
        return length.Value;
    }
}

定义隐式运算符后，我们可以在计算中使用此自定义类型，而无需将它们显式转换为其基础类型：

Length length = new Length { Value = 5.0 };
double finalResult = (length * 1.23) / 42d;
Console.WriteLine($"The answer is {finalResult}.");

这里需要注意的是，可能任何具有此类值的量都需要指示度量单位——在此示例中省略了这一点，只是因为您可以通过多种方式执行此操作，而我不希望这成为重点。因此，在这个例子中有一个假设，即我们确实知道我们在这里使用的是哪个单位。

由于我们添加了运算符，隐式转换通过减少显式转换的数量来简化代码，并通过更清楚地表达意图来提高可读性。如果我们不得不在数学语句中乱扔（double）和其他铸件，它就会开始减损对表达式本身的理解。

C#语言中隐式运算符的缺点

隐式运算符的一大缺点与我们研究的优点之一密切相关。如果我们不小心我们隐式转换到什么，我们可以隐式转换的事实可能会让自己陷入非常奇怪的情况。

让我们介绍另一种也可以转换为替身的自定义类型。我们可以做出与以前类似的假设，即我们知道这种数量表示类型的单位。代码如下，与前一种代码非常相似：

public struct Temperature
{
    public double Value { get; set; }

    // Implicit conversion from Temperature to double
    public static implicit operator double(Temperature temperature)
    {
        return temperature.Value;
    }
}

因为这两种类型都可以隐式转换为双精度，所以我们有能力在不强制转换的情况下编写这样的数学表达式——但我们应该这样做吗？

Length length = new Length { Value = 5.0 };
Temperature temperature = new Temperature { Value = 25.0 };
double finalResult = ((length * temperature) + 42d) / 1.23;
Console.WriteLine($"The answer is {finalResult}.");

在此示例中，隐式运算符允许直接执行Length和Temperature对象之间的相乘，而无需显式转换。孤立地看，允许任何一种类型都可转换为double可能更有意义，但是当它们都可以转换为时，结果可能会出乎意料。

详细地说，举个例子，如果你的长度是米，将它们转换为名为lengthInMeters的double类型并没有太大的牵强。但double本身是无单位的，当我们开始通过混合其他类型来复合它时，跟踪我们*实际上*谈论的单位的负担开始超过隐式转换的好处。在我看来，如果我们被迫在必要时在中间步骤中明确地投射和跟踪转换，那么它的可读性会更高。

当然，这只是一个例子，但关键是，如果你正在进行隐式转换，你可能会失去数据分辨率（在本例中为单位），那么你就有这种事情的风险。没有什么能阻止我们作为C#开发人员这样做——除了其他开发人员的拉取请求和代码审查！

隐式运算符的用例

在本节中，我将介绍C#中隐式运算符的三个实际用例。隐式运算符是一项强大的功能，允许在不同类型的之间进行自动转换。理解和使用隐式运算符可以大大简化代码并提高其可读性。让我们探讨隐式运算符在C#中有用的三个用例。

转换自定义类型——我心目中的金钱

隐式运算符的主要用例之一是转换自定义类型。假设我们有一个自定义Money类型，它表示一定数量的货币。我们可能希望允许从Money到double的隐式转换，以简化计算并支持直接比较。以下是我们如何定义一个隐式运算符来实现这一点：

public struct Money
{
    private readonly double _amount;

    public Money(double amount)
    {
        _amount = amount;
    }

    public double Amount => _amount;

    // Implicitly converts Money to double
    public static implicit operator double(Money money)
    {
        return money._amount;
    }

    // Implicitly converts double to Money
    public static implicit operator Money(double amount)
    {
        return new Money(amount);
    }
}

// Usage
class Program
{
    static void Main(string[] args)
    {
        Money moneyInWallet = new Money(100.50); // $100.50
        double cash = moneyInWallet; // Implicit conversion to double
        
        // Adding more money
        moneyInWallet += 99.50; // Implicit conversion from double to Money, then addition

        Console.WriteLine(cash); // Output: 100.5
        Console.WriteLine(moneyInWallet.Amount); // Output: 200
    }
}

通过定义一个隐式转换运算符从Money到double，我们现在可以直接将Money对象分配给double变量，而无需显式类型转换。如果您想通过拥有一种Money类型来获得更具表现力的财务计算，这可能很有用，而无需强制执行所有操作。

简化数学运算

隐式运算符还可以通过自动将操作数转换为兼容类型来简化数学运算。假设我们有一个表示复数的ComplexNumber类型，我们想对它们执行算术运算。通过使用隐式运算符，我们可以在执行数学运算时无缝地将整数和double转换为ComplexNumber。在这种情况下，我们不仅需要隐式运算符进行转换，还需要一个运算符在两个ComplexNumber实例之间进行算术运算。

下面是一个示例：

public class ComplexNumber
{
    public double Real { get; set; }
    public double Imaginary { get; set; }

    public ComplexNumber(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }

    // Implicitly converts int to ComplexNumber
    public static implicit operator ComplexNumber(int number)
    {
        return new ComplexNumber(number, 0);
    }

    // Implicitly converts double to ComplexNumber
    public static implicit operator ComplexNumber(double number)
    {
        return new ComplexNumber(number, 0);
    }

    // Adds two ComplexNumber instances
    public static ComplexNumber operator +(ComplexNumber a, ComplexNumber b)
    {
        return new ComplexNumber(a.Real + b.Real, a.Imaginary + b.Imaginary);
    }
}

// Usage
ComplexNumber complexNumber = 2.5; // Implicit conversion from double
complexNumber += 3; // Implicit conversion from int
Console.WriteLine(complexNumber.Real); // Output: 5.5

使用隐式运算符，我们可以使用整数或double对ComplexNumber对象执行数学运算，而无需显式转换。如果你正在创建一个应用程序，其中有很多关于这些概念的算术，你可能会发现它提高了代码的可读性，而不必例行地进行强制转换。

与其他库的转换：几何示例

隐式运算符在使用具有不同类型表示相似概念的库或API时特别有用。通过在这些类型之间创建隐式运算符，可以在它们之间无缝转换并简化与库的交互。

例如，考虑我们想要创建的库，该库提供不同的类型来表示2D空间中的点。库可以定义Point2D和Vector2D类型，每个库都有自己的一组操作。通过在这些类型之间定义隐式运算符，用户可以更轻松地互换使用这些对象，具体取决于上下文：

public struct Point2D
{
    // Implicit conversion from Point2D to Vector2D
    public static implicit operator Vector2D(Point2D point)
    {
        return new Vector2D(point.X, point.Y);
    }
}

public struct Vector2D
{
    // Implicit conversion from Vector2D to Point2D
    public static implicit operator Point2D(Vector2D vector)
    {
        return new Point2D(vector.X, vector.Y);
    }
}

有了这些隐式运算符，用户可以根据代码的需要在Point2D和Vector2D对象之间无缝转换：

Point2D point = new Point2D(2, 3);
Vector2D vector = new Vector2D(4, 5);

// Implicit conversion from Point2D to Vector2D
Vector2D convertedVector = point;

// Implicit conversion from Vector2D to Point2D
Point2D convertedPoint = vector;

在此方案中，隐式运算符通过允许用户使用具有表示不同概念的不同对象来使用相同的基础数据，从而简化代码并使其更具表现力。在类似情况下，如果我们将第三方库合并到我们的代码库中，并希望在与它交互时提供一定程度的灵活性，可能会有好处。对于我们拥有的类型，我们可以提供对相关库的隐式转换，并且在与库交互时可以简化代码库中的逻辑。

在C#中包装隐式运算符

在本文中，我们探讨了C#中的隐式运算符，以及它们如何简化代码和提高代码可读性。隐式运算符允许在不同类型的类型之间进行自动转换，从而更轻松地在C#中处理数据和对象。

我个人对C#中的隐式运算符的看法是，类型转换很容易“出错”。如果你不确定自己在做什么，我认为这是一件容易的事情，你可能会搞砸并在你的代码中创造更多的复杂性，而不是从中获得潜在的可读性。但是，如果您正在创建强调在多种类型之间工作作为您正在执行的核心工作的代码，则可能会更好地了解正确使用这些类型的有效方法。