CODEWITHSUNDEEP
c#.nettype-conversion
fhnaseer
fhnaseer

Reputation: 7277

Converting object of a class to of another one

I have two classes which have are nearly equal except the data types stored in them. One class contains all double values while other contains all float values.

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

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

Now I have a point of DoubleClass which I want to convert to FloatClass.

var doubleObject = new DoubleClass();

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

One simple way is to make a method which creates a new FloatClass object, fills all values and return it. Is there any other efficient way to do this.

Upvotes: 23

Views: 115177

Answers (8)

Mohammad Komaei
Mohammad Komaei

Reputation: 9702

Add a class for thease extention methods :

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

Use :

using YourExtentionMethodNamespace;

Class2 obj2 = obj1.ToObject<Class2>();
List<Class2> lst2 = _db.Blogs.ToList().ToObjectList<Class2>();

Upvotes: 2

letiagoalves
letiagoalves

Reputation: 11302

Use a conversion operator:

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

And then just use it:

var convertedObject = (FloatClass) doubleObject;

Edit

I changed the operator to explicit instead of implicit since I was using a FloatClass cast in the example. I prefer to use explicit over implicit so it forces me to confirm what type the object will be converted to (to me it means less distraction errors + readability).

However, you can use implicit conversion and then you would just need to do:

var convertedObject = doubleObject;

Reference

Upvotes: 32

user11657764
user11657764

Reputation:

Best way for Convert

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

For Usage

var doubleClass = new DoubleClass {
   x = 10,
   y = 20
};
var floatClass = JsonConvert.DeserializeObject<FloatClass>(doubleClass.ConvertObjectToJson());

Upvotes: 0

Aamol
Aamol

Reputation: 1199

The simplest way to do this is by using serializer. Use Newtonsoft JSON serializer which works best.

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

Upvotes: 0

Rupesh Dahibavkar
Rupesh Dahibavkar

Reputation: 39

Best way is Serialize object and again desalinize it

Upvotes: -3

Tim Schmelter
Tim Schmelter

Reputation: 460360

You could add an implicit type conversion operator:

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

Now this works:

DoubleClass doubleObject = new DoubleClass();
FloatClass convertedObject = doubleObject;

Upvotes: 3

Darren
Darren

Reputation: 70804

Sounds like you could use generics here:

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

Upvotes: 7

Tigran
Tigran

Reputation: 62265

You can use Conversion Operators to achieve this.

Fr example: 

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;

Upvotes: 5

Related Questions