C# 的一个鲜为人知的特性是创建隐式或显式用户定义类型转换的可能性。我已经编写 C# 代码 6 年了，但我从未使用过它。所以，我担心我可能会错过好机会。
用户定义转换的合法、良好用途是什么？您是否有比仅定义自定义方法更好的示例？
--
事实证明，微软有一些关于转换的设计指南，其中最相关的是：
如果最终用户没有明确期望此类转换，请勿提供转换运算符。
但是什么时候会“预期”转换呢？在玩具编号类之外，我无法弄清楚任何真实世界的用例。
以下是答案中提供的示例的摘要：
模式似乎是：隐式转换在定义数值/值类型时主要（仅？）有用，转换由公式定义。回想起来，这是显而易见的。不过，我想知道非数字类是否也可以从隐式转换中受益……？
当与不同类型进行自然而清晰的转换时，您可以使用转换运算符。
例如，假设您有一个表示温度的数据类型：
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);
}
}
使用隐式运算符，您可以将 double 分配给温度变量，它将自动用作 Kelvin：
Temperature a = new Temperature(100, TemperatureScale.Celcius);
Temperature b = 373.15; // Kelvin is default
正如评论中提到的，度数和旋转是避免混淆双精度值的一个很好的例子，尤其是在 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
正如我所说，我想再通过这些类，并可能消除double隐式转换Radians以避免一些可能的极端情况混淆和编译器歧义。这些实际上在我们创建 static 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);
}
}
我用它来无缝转换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");
}
}
假设您有一个用于商店应用程序的产品（例如玩具）类：
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。
希望这可以帮助！
一般来说，如果两件事在逻辑上是可转换的。我在这种情况下使用它们来提供更流畅的代码。我有时也会使用它们来绕过那些不太像我期望的那样工作的语言特性。
这是一个非常简单，人为的示例，说明了与我在生产中使用的类似的最后一个想法......
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;
}
}
没有普遍的答案。我会小心使用它，并且只有在保持代码易于理解和直截了当的情况下（即它显示出预期的行为）。
所以我可以根据一个实际的例子给你一个答案，如果你跟着它，你就会明白什么时候使用，什么时候最好不要使用转换运算符：
我最近想用一种更简单的方法来处理 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...
}
像这样的指导会不会更容易：
var guids = new EasyGuid[30]; // create array with 30 Guids (value null)
然后可以像这样使用两个示例中的指南
foreach (Guid g in guids)
{
g.Dump();
}
换句话说，它们可以在需要使用时隐式转换为“普通”Guid。在第二个示例中，如果它们为空，则动态隐式分配空 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