什么时候应该在 C# 中定义（显式或隐式）转换运算符？ [关闭]

Question

C# 的一个鲜为人知的特性是可以创建隐式或显式的用户定义类型转换。 我已经编写 C# 代码 6 年了，但我从未使用过它。 所以，恐怕我可能会错过好机会。

什么是用户定义转换的合法、好的用途？ 您是否有比仅定义自定义方法更好的示例？

——

事实证明，微软有一些关于转换的设计指南，其中最相关的是：

如果最终用户没有明确预期此类转换，则不要提供转换运算符。

但是什么时候转换是“预期的”？ 在玩具编号类之外，我无法弄清楚任何现实世界的用例。

以下是答案中提供的示例的摘要：

弧度/度/双
极坐标/点二维
开尔文/华氏度/摄氏度

模式似乎是：隐式转换主要（仅？）在定义数值/值类型时有用，转换由公式定义。 回想起来，这是很明显的。 不过，我想知道非数字类是否也可以从隐式转换中受益..？

Answer 1

当与不同类型之间进行自然而清晰的转换时，您可以使用转换运算符。

例如，假设您有一个用于表示温度的数据类型：

public enum TemperatureScale { Kelvin, Farenheit, Celsius }

public struct Temperature {

  private TemperatureScale _scale;
  private double _temp;

  public Temperature(double temp, TemperatureScale scale) {
    _scale = scale;
    _temp = temp;
  }

  public static implicit operator Temperature(double temp) {
    return new Temperature(temp, TemperatureScale.Kelvin);
  }

}

使用隐式运算符，您可以为温度变量分配一个双精度值，它会自动用作开尔文：

Temperature a = new Temperature(100, TemperatureScale.Celcius);
Temperature b = 373.15; // Kelvin is default

Answer 2

正如评论中提到的，度数和旋转是一个很好的例子，可以避免混淆双值，尤其是在 API 之间。

我取出了我们目前正在使用的Radians和Degrees类，它们在这里。 现在看看它们（经过这么长时间）我想清理它们（尤其是评论/文档）并确保它们经过正确测试。 谢天谢地，我已经设法在日程安排中抽出时间来这样做。 无论如何，使用这些需要您自担风险，我不能保证这里的所有数学运算是否正确，因为我很确定我们还没有实际使用/测试我们编写的所有功能。

弧度

/// <summary>
/// Defines an angle in Radians
/// </summary>
public struct Radians
{
    public static readonly Radians ZERO_PI = 0;
    public static readonly Radians ONE_PI = System.Math.PI;
    public static readonly Radians TWO_PI = ONE_PI * 2;
    public static readonly Radians HALF_PI = ONE_PI * 0.5;
    public static readonly Radians QUARTER_PI = ONE_PI * 0.25;
    
    #region Public Members

    /// <summary>
    /// Angle value
    /// </summary>
    public double Value;
    /// <summary>
    /// Finds the Cosine of the angle
    /// </summary>
    public double Cos
    {
        get
        {
            return System.Math.Cos(this);
        }
    }
    /// <summary>
    /// Finds the Sine of the angle
    /// </summary>
    public double Sin
    {
        get
        {
            return System.Math.Sin(this);
        }
    }

    #endregion

    /// <summary>
    /// Constructor
    /// </summary>
    /// <param name="value">angle value in radians</param>
    public Radians(double value)
    {
        this.Value = value;
    }
    /// <summary>
    /// Gets the angle in degrees
    /// </summary>
    /// <returns>Returns the angle in degrees</returns>
    public Degrees GetDegrees()
    {
        return this;
    }

    public Radians Reduce()
    {
        double radian = this.Value;
        bool IsNegative = radian < 0;
        radian = System.Math.Abs(radian);
        while (radian >= System.Math.PI * 2)
        {
            radian -= System.Math.PI * 2;
        }
        if (IsNegative && radian != 0)
        {
            radian = System.Math.PI * 2 - radian;
        }
        return radian;
    }

    #region operator overloading

    /// <summary>
    /// Conversion of Degrees to Radians
    /// </summary>
    /// <param name="deg"></param>
    /// <returns></returns>
    public static implicit operator Radians(Degrees deg)
    {
        return new Radians(deg.Value * System.Math.PI / 180);
    }
    /// <summary>
    /// Conversion of integer to Radians
    /// </summary>
    /// <param name="i"></param>
    /// <returns></returns>
    public static implicit operator Radians(int i)
    {
        return new Radians((double)i);
    }
    /// <summary>
    /// Conversion of float to Radians
    /// </summary>
    /// <param name="f"></param>
    /// <returns></returns>
    public static implicit operator Radians(float f)
    {
        return new Radians((double)f);
    }
    /// <summary>
    /// Conversion of double to Radians
    /// </summary>
    /// <param name="dbl"></param>
    /// <returns></returns>
    public static implicit operator Radians(double dbl)
    {
        return new Radians(dbl);
    }
    /// <summary>
    /// Conversion of Radians to double
    /// </summary>
    /// <param name="rad"></param>
    /// <returns></returns>
    public static implicit operator double(Radians rad)
    {
        return rad.Value;
    }
    /// <summary>
    /// Add Radians and a double
    /// </summary>
    /// <param name="rad"></param>
    /// <param name="dbl"></param>
    /// <returns></returns>
    public static Radians operator +(Radians rad, double dbl)
    {
        return new Radians(rad.Value + dbl);
    }
    /// <summary>
    /// Add Radians to Radians
    /// </summary>
    /// <param name="rad1"></param>
    /// <param name="rad2"></param>
    /// <returns></returns>
    public static Radians operator +(Radians rad1, Radians rad2)
    {
        return new Radians(rad1.Value + rad2.Value);
    }
    /// <summary>
    /// Add Radians and Degrees
    /// </summary>
    /// <param name="rad"></param>
    /// <param name="deg"></param>
    /// <returns></returns>
    public static Radians operator +(Radians rad, Degrees deg)
    {
        return new Radians(rad.Value + deg.GetRadians().Value);
    }
    /// <summary>
    /// Sets Radians value negative
    /// </summary>
    /// <param name="rad"></param>
    /// <returns></returns>
    public static Radians operator -(Radians rad)
    {
        return new Radians(-rad.Value);
    }
    /// <summary>
    /// Subtracts a double from Radians
    /// </summary>
    /// <param name="rad"></param>
    /// <param name="dbl"></param>
    /// <returns></returns>
    public static Radians operator -(Radians rad, double dbl)
    {
        return new Radians(rad.Value - dbl);
    }
    /// <summary>
    /// Subtracts Radians from Radians
    /// </summary>
    /// <param name="rad1"></param>
    /// <param name="rad2"></param>
    /// <returns></returns>
    public static Radians operator -(Radians rad1, Radians rad2)
    {
        return new Radians(rad1.Value - rad2.Value);
    }
    /// <summary>
    /// Subtracts Degrees from Radians
    /// </summary>
    /// <param name="rad"></param>
    /// <param name="deg"></param>
    /// <returns></returns>
    public static Radians operator -(Radians rad, Degrees deg)
    {
        return new Radians(rad.Value - deg.GetRadians().Value);
    }


    #endregion

    public override string ToString()
    {
        return String.Format("{0}", this.Value);
    }

    public static Radians Convert(object value)
    {
        if (value is Radians)
            return (Radians)value;
        if (value is Degrees)
            return (Degrees)value;

        return System.Convert.ToDouble(value);
    }
}

学位

public struct Degrees
{
    public double Value;       

    public Degrees(double value) { this.Value = value; }

    public Radians GetRadians()
    {
        return this;
    }

    public Degrees Reduce()
    {
        return this.GetRadians().Reduce();
    }

    public double Cos
    {
        get
        {
            return System.Math.Cos(this.GetRadians());
        }
    }

    public double Sin
    {
        get
        {
            return System.Math.Sin(this.GetRadians());
        }
    }

    #region operator overloading

    public static implicit operator Degrees(Radians rad)
    {
        return new Degrees(rad.Value * 180 / System.Math.PI);
    }

    public static implicit operator Degrees(int i)
    {
        return new Degrees((double)i);
    }

    public static implicit operator Degrees(float f)
    {
        return new Degrees((double)f);
    }

    public static implicit operator Degrees(double d)
    {
        return new Degrees(d);
    }

    public static implicit operator double(Degrees deg)
    {
        return deg.Value;
    }

    public static Degrees operator +(Degrees deg, int i)
    {
        return new Degrees(deg.Value + i);
    }

    public static Degrees operator +(Degrees deg, double dbl)
    {
        return new Degrees(deg.Value + dbl);
    }

    public static Degrees operator +(Degrees deg1, Degrees deg2)
    {
        return new Degrees(deg1.Value + deg2.Value);
    }

    public static Degrees operator +(Degrees deg, Radians rad)
    {
        return new Degrees(deg.Value + rad.GetDegrees().Value);
    }

    public static Degrees operator -(Degrees deg)
    {
        return new Degrees(-deg.Value);
    }

    public static Degrees operator -(Degrees deg, int i)
    {
        return new Degrees(deg.Value - i);
    }

    public static Degrees operator -(Degrees deg, double dbl)
    {
        return new Degrees(deg.Value - dbl);
    }

    public static Degrees operator -(Degrees deg1, Degrees deg2)
    {
        return new Degrees(deg1.Value - deg2.Value);
    }

    public static Degrees operator -(Degrees deg, Radians rad)
    {
        return new Degrees(deg.Value - rad.GetDegrees().Value);
    }

    #endregion

    public override string ToString()
    {
        return String.Format("{0}", this.Value);
    }

    public static Degrees Convert(object value)
    {
        if (value is Degrees)
            return (Degrees)value;
        if (value is Radians)
            return (Radians)value;

        return System.Convert.ToDouble(value);
    }
}

一些示例用法

这些在使用 API 时确实受益。 虽然在内部，您的组织可能决定严格遵守度数或弧度以避免混淆，但至少对于这些类，您可以使用最有意义的类型。 例如，公开使用的 API 或 GUI API 可以使用Degrees而您的大量数学/三角函数或内部使用可能使用Radians 。 考虑以下类/打印功能：

public class MyRadiansShape
{
    public Radians Rotation { get; set; }
}

public class MyDegreesShape
{
    public Degrees Rotation { get; set; }
}

public static void PrintRotation(Degrees degrees, Radians radians)
{
    Console.WriteLine(String.Format("Degrees: {0}, Radians: {1}", degrees.Value, radians.Value));
}

是的，代码非常人为（而且非常模棱两可）但是没关系！ 只是展示它如何帮助减少意外混淆。

var radiansShape = new MyRadiansShape() { Rotation = Math.PI / 2}; //prefer "Radians.HALF_PI" instead, but just as an example
var degreesShape = new MyDegreesShape() { Rotation = 90 };

PrintRotation(radiansShape.Rotation, radiansShape.Rotation);
PrintRotation(degreesShape.Rotation, degreesShape.Rotation);
PrintRotation(radiansShape.Rotation + degreesShape.Rotation, radiansShape.Rotation + degreesShape.Rotation);

//Degrees: 90, Radians: 1.5707963267949
//Degrees: 90, Radians: 1.5707963267949
//Degrees: 180, Radians: 3.14159265358979

然后它们对于实现基于角度的其他数学概念非常有用，例如极坐标：

double distance = 5;
Polar polarCoordinate = new Polar(distance, (degreesShape.Rotation - radiansShape.Rotation) + Radians.QUARTER_PI);
Console.WriteLine("Polar Coordinate Angle: " + (Degrees)polarCoordinate.Angle); //because it's easier to read degrees!
//Polar Coordinate Angle: 45

最后，您可以实现一个Point2D类（或使用 System.Windows.Point）与与Polar隐式转换：

Point2D cartesianCoordinate = polarCoordinate;
Console.WriteLine(cartesianCoordinate.X + ", " + cartesianCoordinate.Y);
//3.53553390593274, 3.53553390593274

正如我所说，我想在这些类上再做一遍，并可能消除对Radians的double隐式转换，以避免可能出现的几种极端情况混淆和编译器歧义。 这些实际上在我们创建静态ONE_PI 、 HALF_PI （等等）字段之前就已经存在，我们正在从Math.PI double 的某个倍数进行转换。

编辑：这是Polar类，作为附加隐式转换的演示。 它利用了Radians类（以及它的隐式转换）及其上的辅助方法和Point2D类。 我没有在这里包括它，但Polar类可以轻松实现与Point2D类交互的运算符，但这些与本讨论无关。

public struct Polar
{
    public double Radius;
    public Radians Angle;

    public double X { get { return Radius * Angle.Cos; } }
    public double Y { get { return Radius * Angle.Sin; } }

    public Polar(double radius, Radians angle)
    {
        this.Radius = radius;
        this.Angle = angle;
    }

    public Polar(Point2D point)
        : this(point.Magnitude(), point.GetAngleFromOrigin())
    {
    }

    public Polar(Point2D point, double radius)
        : this(radius, point.GetAngleFromOrigin())
    {
    }

    public Polar(Point2D point, Point2D origin)
        : this(point - origin)
    {
    }

    public Point2D ToCartesian()
    {
        return new Point2D(X, Y);
    }
    
    public static implicit operator Point2D(Polar polar)
    {
        return polar.ToCartesian();
    }

    public static implicit operator Polar(Point2D vector)
    {
        return new Polar(vector);
    }
}

Answer 3

我使用它来实现从DateTime到"yyyyMMdd"或其对应的int (yyyyMMdd) 值的无缝转换。

例如：

void f1(int yyyyMMdd);
void f2(string yyyyMMdd);

...
f1(30.YearsFrom(DateTime.Today));
f2(30.YearsFrom(DateTime.Today));

...
public static DateAsYyyyMmDd YearsFrom(this int y, DateTime d) 
{
    return new DateAsYyyyMmDd(d.AddYears(y));
}

...
public class DateAsYyyyMmDd
{
    private readonly DateTime date;

    public DateAsYyyyMmDd(DateTime date)
    {
        this.date = date;
    }

    public static implicit operator int(DateOrYyyyMmDd d)
    {
        return Convert.ToInt32(d.date.ToString("yyyyMMdd"));
    }

    public static implicit operator string(DateOrYyyyMmDd d)
    {
        return d.date.ToString("yyyyMMdd");
    }
}

Answer 4

假设您有一个用于商店应用程序的产品（例如玩具）的类：

class Product
{
    string name;
    decimal price;
    string maker;
    //etc...
}

您可以定义可能执行以下操作的显式转换：

public static explicit operator string(Product p)
{
    return "Product Name: " + p.name + " Price: " + p.price.ToString("C") + " Maker: " + p.maker;
    // Or you might just want to return the name.
}

这样，当您执行以下操作时：

textBox1.Text = (string)myProduct;

它会将输出格式化为Product类的显式运算符中的内容。

如果最终用户没有明确预期此类转换，则不要提供转换运算符。

Microsoft 的意思是，如果您确实提供了转换运算符，则不会返回意外结果。 使用我们Product类的最后一个示例，这将返回一个意外的结果：

public static explicit operator string(Product p)
{
    return (p.price * 100).ToString();
    //...
}

显然没有人会真正这样做，但如果其他人使用Product类并使用显式字符串转换，他们不会期望它返回价格乘以 100。

希望这可以帮助！

Answer 5

一般来说，如果两件事在逻辑上是可以转换的。 我在这种情况下使用它们来提供更流畅的代码。 我有时也使用它们来解决与我期望的方式不太一样的语言功能。

这是一个非常简单、人为设计的示例，它说明了与我在生产中使用的类似的最后一个想法......

class Program
{. 
    static void Main(string[] args)
    {
        Code code1 = new Code { Id = 1, Description = "Hi" };
        Code code2 = new Code { Id = 2, Description = "There" };

        switch (code1)
        {
            case 23: 
              // do some stuff
              break;
            // other cases...
        }
    }
}

public class Code
{
    private int id;
    private string description;

    public int Id { get; set; }
    public string Description { get; set; }

    public static implicit operator int(Code code)
    {
        return code.Id;
    }
}

Answer 6

没有普遍的答案。 我会小心地使用它，并且只有在保持代码易于理解和直截了当的情况下（即它显示出预期的行为）。

所以我可以根据一个实际的例子给你一个答案，如果你跟着它，你就会明白什么时候使用，什么时候最好不要使用转换运算符：

我最近想有一种更简单的方法来处理 Guid。 我的设计目标是：简化语法和初始化，简化转换和变量赋值。

如您所知，如果您需要创建 GUID，使用起来有点麻烦：

示例 1：

盒子外面：

var guids = new Guid[] {
  new Guid("2f78c861-e0c3-4d83-a2d2-cac269fb87f1"), new Guid("2f78c861-e0c3-4d83-a2d2-cac269fb87f2"),
  new Guid("2f78c861-e0c3-4d83-a2d2-cac269fb87f3")
};

如果您可以将 GUID 字符串隐式转换为字符串，例如：

var guids = new EasyGuid[] {
    "2f78c861-e0c3-4d83-a2d2-cac269fb87f1", "2f78c861-e0c3-4d83-a2d2-cac269fb87f2",
    "2f78c861-e0c3-4d83-a2d2-cac269fb87f3"
};

这将允许将 GUID 列表直接从 JSON 文件粘贴到 C# 代码中。

示例 2：

要初始化数组，您需要执行以下操作：

var guids = new Guid[30];
for (int i = 0; i < 30; i++)
{
    guids[i] = System.Guid.Empty; // Guid with 000...
}

像这样的 Guids 会不会更容易：

var guids = new EasyGuid[30]; // create array with 30 Guids (value null)

然后可以使用来自两个示例的 guids

foreach (Guid g in guids)
{
        g.Dump();
}

换句话说，它们可以在需要使用时隐式转换为“正常”Guid。 在第二个示例中，如果它们为 null，则动态隐式分配一个 Empty Guid。

你怎么能这样做？ 您不能从 System.Guid 继承。 但是您可以使用隐式转换。 看看这个类，我称之为EasyGuid ，它使上面的声明成为可能：

/// <summary>
/// Easy GUID creation
/// Written by Matt, 2020
/// </summary>
public class EasyGuid
{
    // in case you want to replace GUID generation 
    // by RT.Comb, call Provider.PostgreSql.Create()
    private static System.Guid NewGuid => System.Guid.NewGuid();

    private System.Guid _guid = EasyGuid.NewGuid;

    public EasyGuid()
    {
        _guid = NewGuid;
    }

    public EasyGuid(string s)
    {
        _guid = new System.Guid(s); // convert string to Guid
    }

    // converts string to Guid
    public static implicit operator EasyGuid(string s) => new EasyGuid(s);

    // converts EasyGuid to Guid, create empty guid (Guid with 0) if null
    public static implicit operator System.Guid(EasyGuid g)
                                    => (g == null) ? System.Guid.Empty : g.ToGuid();

    // converts EasyGuid to Guid?, null will be passed through
    public static implicit operator System.Guid?(EasyGuid g)
                                    => (g == null) ? null : (Guid?)g.ToGuid();
                                    
    public override string ToString() => _guid.ToString();
    public System.Guid ToGuid() => _guid;
}

您可以看到EasyGuid可以将字符串隐式转换为 EasyGuid 并且可以将 EasyGuid 转换为 Guid - 通过调用ToGuid()隐式或显式。 它也可以打印为字符串，因为我已经覆盖了.ToString() 。

最后，我希望能够轻松地即时生成新的 GUID。 我通过写作实现了这一点。

    // converts EasyGuid to Guid, create empty guid (Guid with 0) if null
    public static implicit operator System.Guid(EasyGuid g)
                                    => (g == null) ? EasyGuid.NewGuid : g.ToGuid();

这会产生这样的效果

var guids = new EasyGuid[30];

将在转换为 GUID 后立即生成新的 GUID。 但是我从@OskarBerggren那里得到了反馈，即这种方法 - 虽然它很容易实现，但会引起混乱 - 代码对于其他阅读它的人来说不再明显（感谢 Oskar 的提示！）。 它还可能导致意外问题（错误）。 还记得微软说过的话：

如果最终用户没有明确预期此类转换，则不要提供转换运算符。

因此，我不是通过隐式转换来实现的，而是使用如下扩展方法：

public static class Extensions
{
    public static System.Guid[] ToGuids(this EasyGuid[] guidArray, bool replaceNullByNewGuid = false)
        => guidArray.ToList().ToGuids(replaceNullByNewGuid).ToArray();
        
    public static List<System.Guid> ToGuids(this List<EasyGuid> easyGuidList, bool replaceNullByNewGuid = false)
    {
        var guidList = new List<Guid>();
        foreach (var g in easyGuidList)
        {
            Guid result = (g!=null) ? g : ((replaceNullByNewGuid) ? new EasyGuid().ToGuid() : System.Guid.Empty);
            guidList.Add(result);
        }
        return guidList;
    }
}

这更简单，因为现在您可以选择：

// shorter: .ToGuids(true)
var guids = new EasyGuid[30].ToGuids(replaceNullByNewGuid: true);

如果您只想创建一个带有空 Guid 的数组：

var guids = new EasyGuid[30].ToGuids();

这样做（与 GUIDS 列表相同）。

此示例表明隐式转换运算符很容易因意外行为而引起混淆。 有时，最好使用扩展方法（如下所示）。

我认为这个例子表明，在某些情况下，转换运算符可以让您的生活更轻松，而在其他情况下，您应该停下来思考并找到更明显的实现方式。

为了完整性：其他情况是：

var eg1 = new EasyGuid();  // simple case: new Guid
Guid g = eg1; g.Dump();    // straight-forward conversion
    
EasyGuid eg2 = null;       // null-handling
Guid g2 = eg2; g2.Dump();  // converted to 00000000-0000-0000-0000-000000000000
Guid? g3 = eg2; g3.Dump(); // will be null

什么时候应该在 C# 中定义（显式或隐式）转换运算符？ [关闭]

问题描述

6 个解决方案

解决方案1
9 2012-08-26 01:28:24

解决方案2
5 已采纳 2012-09-01 22:40:49

弧度

学位

一些示例用法

解决方案3
2 2013-12-30 20:55:37

解决方案4
1 2012-08-26 01:16:43

解决方案5
0 2012-08-26 01:20:01

解决方案6
0 2020-08-04 08:32:29

什么时候应该在 C# 中定义（显式或隐式）转换运算符？ [关闭]

问题描述

6 个解决方案

解决方案1 9 2012-08-26 01:28:24

解决方案2 5 已采纳 2012-09-01 22:40:49

弧度

学位

一些示例用法

解决方案3 2 2013-12-30 20:55:37

解决方案4 1 2012-08-26 01:16:43

解决方案5 0 2012-08-26 01:20:01

解决方案6 0 2020-08-04 08:32:29

解决方案1
9 2012-08-26 01:28:24

解决方案2
5 已采纳 2012-09-01 22:40:49

解决方案3
2 2013-12-30 20:55:37

解决方案4
1 2012-08-26 01:16:43

解决方案5
0 2012-08-26 01:20:01

解决方案6
0 2020-08-04 08:32:29