19

除了存储在其中的数据类型外，我有两个几乎相等的类。一个类包含所有双精度值，而另一个包含所有浮点值。

class DoubleClass
{
    double X;
    double Y;
    double Z;
}

class FloatClass
{
    float X;
    float Y;
    float Z;
}

现在我有一个要转换为 FloatClass 的 DoubleClass 点。

var doubleObject = new DoubleClass();

var convertedObject = (FloatClass)doubleObject; // TODO: This

一种简单的方法是创建一个方法来创建一个新的 FloatClass 对象，填充所有值并返回它。有没有其他有效的方法来做到这一点。

4

8 回答 8

28

使用转换运算符：

public static explicit operator FloatClass (DoubleClass c) {
   FloatCass fc = new FloatClass();
   fc.X = (float) c.X;
   fc.Y = (float) c.Y;
   fc.Z = (float) c.Z;
   return fc;
}

然后就使用它：

var convertedObject = (FloatClass) doubleObject;

编辑

我将运算符更改为，explicit而不是implicit因为我FloatClass在示例中使用了演员表。我更喜欢使用explicitover，implicit所以它迫使我确认对象将被转换为什么类型（对我来说，这意味着更少的干扰错误 + 可读性）。

但是，您可以使用implicit转换，然后您只需要执行以下操作：

var convertedObject = doubleObject;

参考

于 2013-09-13T10:42:42.370 回答
6

听起来你可以在这里使用泛型：

 public class GenericClass<T>
 {
    T X { get; set; }
    T Y { get; set; }
    T Z { get; set; }
 }

 GenericClass<float> floatClass = new GenericClass<float>();
 GenericClass<double> doubleClass = new GenericClass<double>();
于 2013-09-13T10:41:48.240 回答
5

您可以使用转换运算符来实现这一点。

举例：

struct FloatClass
{
    public FloatClass(DoubleClass dClass) {
        //conversion...
    }
    ... 
    public static explicit operator FloatClass(DoubleClass dClass) 
    {
        FloatClassd = new FloatClass(dClass);  // explicit conversion

        return d;
    }
}


var convertedObject = (FloatClass)doubleObject;
于 2013-09-13T10:41:22.083 回答
2

您可以添加一个隐式类型转换运算符：

public class DoubleClass
{
    public double X;
    public double Y;
    public double Z;

    public static implicit operator FloatClass(DoubleClass d)
    {
        return new FloatClass { X = (float)d.X, Y = (float)d.Y, Z = (float)d.Z };
    }
}

现在这有效：

DoubleClass doubleObject = new DoubleClass();
FloatClass convertedObject = doubleObject;
于 2013-09-13T10:43:50.730 回答
1

为这些扩展方法添加一个类：

public static class ExtensionMethods
{
    public static T ToObject<T>(this Object fromObject)
    {
        return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(fromObject));
    }


    public static List<T> ToObjectList<T>(this Object fromObject)
    {
        return JsonConvert.DeserializeObject<List<T>>(JsonConvert.SerializeObject(fromObject));
    }
}

利用 ：

using YourExtentionMethodNamespace;

Class2 obj2 = obj1.ToObject<Class2>();
List<Class2> lst2 = _db.Blogs.ToList().ToObjectList<Class2>();
于 2020-12-28T07:52:25.913 回答
1

最简单的方法是使用序列化程序。使用效果最好的 Newtonsoft JSON 序列化程序。

使用 Newtonsoft.Json；

  private void Convert()
    {
        DoubleClass doubleClass = new DoubleClass {X = 123.123, Y = 321.321, Z = 111.111};
        var serializedoubleClass = JsonConvert.SerializeObject(doubleClass);
        var floatClass = JsonConvert.DeserializeObject(serializedoubleClass, typeof(FloatClass));
    }
于 2017-02-28T07:01:18.913 回答
0

转换的最佳方式

public static class Extention {
     public static string ConvertObjectToJson(this object ob)
     {
         return JsonConvert.SerializeObject(ob);
     }
}

用途

var doubleClass = new DoubleClass {
   x = 10,
   y = 20
};
var floatClass = JsonConvert.DeserializeObject<FloatClass>(doubleClass.ConvertObjectToJson());
于 2020-03-30T06:01:49.220 回答
-3

最好的方法是序列化对象并再次淡化它

于 2014-04-24T13:52:22.347 回答