那些遇到过的问题

我应该何时在C#中定义(显式或隐式)转换运算符？

Eld*_*rum 10 c# casting operator-overloading implicit-conversion explicit-conversion

C#的一个鲜为人知的特性是可以创建隐式或显式的用户定义类型转换.我已经写了6年的C#代码了,我从来没有用过它.所以,我担心我可能错过了很好的机会.

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

-

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

如果最终用户未明确预期此类转换,请勿提供转换运算符.

但什么时候转换"预期"？在玩具编号课程之外,我无法弄清楚任何真实世界的用例.

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

  • 弧度/度/双
  • 极地/的Point2D
  • 开尔文/华氏/摄氏度

模式似乎是:隐式转换大多数(仅？)在定义数值/值类型时很有用,转换由公式定义.回想起来,这是显而易见的.不过,我想知道非数字类是否也可以从隐式转换中受益..？

Guf*_*ffa 9

当与其他类型进行自然而明确的转换时,您可以使用转换运算符.

比如说你有一个表示温度的数据类型:

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);
  }

}
Run Code Online (Sandbox Code Playgroud)

使用隐式运算符,您可以为温度变量赋值,它将自动用作开尔文:

Temperature a = new Temperature(100, TemperatureScale.Celcius);
Temperature b = 373.15; // Kelvin is default
Run Code Online (Sandbox Code Playgroud)

  • 难道你不应该把它实际上作为3个单独的类(Kelvin,Farenheit,Celsius)实现它们之间的隐式转换和double吗？ (2认同)

Chr*_*air 6

正如评论中所提到的,度和旋转是避免混合双值的一个很好的例子,尤其是在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);
    }
}
Run Code Online (Sandbox Code Playgroud)

学位

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);
    }
}
Run Code Online (Sandbox Code Playgroud)

一些示例用法

这些在使用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));
}
Run Code Online (Sandbox Code Playgroud)

是的,代码非常人为(而且非常模糊)但是没关系!只是展示它如何帮助减少意外混淆.

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
Run Code Online (Sandbox Code Playgroud)

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

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
Run Code Online (Sandbox Code Playgroud)

最后,您可以Point2D使用隐式转换实现一个类(或使用System.Windows.Point)Polar:

Point2D cartesianCoordinate = polarCoordinate;
Console.WriteLine(cartesianCoordinate.X + ", " + cartesianCoordinate.Y);
//3.53553390593274, 3.53553390593274
Run Code Online (Sandbox Code Playgroud)

正如我所说的,我想在这些类中进行另一次传递,并且可能会消除double隐式转换,Radians以避免可能的几个极端情况混淆和编译器模糊.在我们创建静态(等等)字段之前,它们实际上就存在了ONE_PI,HALF_PI我们正在从Math.PIdouble的一些倍数转换.

编辑:这是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);
    }
}
Run Code Online (Sandbox Code Playgroud)

归档时间：

查看次数：

2214 次

最近记录：

12 年 前
相关归档
如何在C#中获得CPU使用率？ 191
如何使用Swashbuckle在WebAPI上省略Swagger文档中的方法 110
将UTF-8转换为base64字符串 47
如何在.Net/C#中将日期转换为HTTP格式的日期# 45
实体框架抛出异常 - 无效的对象名称'dbo.BaseCs' 42
使用比较运算符时检查多个值 11
将 null 转换为任何类型 5
了解Java中的Casting 4
编译器错误CS0029:"if(int&int)" 3
为什么 libxml2 在 C/C++ 代码中到处都使用“BAD_CAST”？ 3
难疑归档
如何在本地和远程删除Git分支？ 16311
C#中字符串和字符串有什么区别？ 6250
撤消git rebase 2965
是否有唯一的Android设备ID？ 2645
在GitHub上使用https://时有没有办法跳过密码输入？ 1806
为什么将0.1f改为0会使性能降低10倍？ 1491
从客户端检测到潜在危险的Request.Form值 1437
如何在Xcode 4中"添加现有框架"？ 1426
如何检查对象是否在JavaScript中具有属性？ 1396
确定数组是否包含值 1300