web-dev-qa-db-fra.com

Conversion d'un objet d'une classe en une autre

J'ai deux classes qui sont presque égales sauf les types de données qui y sont stockés. Une classe contient toutes les valeurs doubles tandis que l'autre contient toutes les valeurs flottantes.

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

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

J'ai maintenant un point de DoubleClass que je veux convertir en FloatClass.

var doubleObject = new DoubleClass();

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

Une façon simple consiste à créer une méthode qui crée un nouvel objet FloatClass, remplit toutes les valeurs et le renvoie. Existe-t-il un autre moyen efficace de procéder?.

c#.nettype-conversion
14
fhnaseer

Utilisez un opérateur de conversion: 

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

Et puis il suffit de l'utiliser:

var convertedObject = (FloatClass) doubleObject;

Modifier

J'ai changé l'opérateur en explicit au lieu de implicit car j'utilisais un cast FloatClass dans l'exemple. Je préfère utiliser explicit plutôt que implicit donc cela me force à confirmer dans quel type l'objet sera converti (pour moi, cela signifie moins d'erreurs de distraction + lisibilité).

Cependant, vous pouvez utiliser la conversion implicit et il vous suffira alors de faire:

var convertedObject = doubleObject;

Référence

21
letiagoalves

On dirait que vous pouvez utiliser des génériques ici:

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

Vous pouvez utiliser Opérateurs de conversion pour y parvenir.

Par exemple:

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;
3
Tigran

Vous pouvez ajouter un opérateur de conversion de type implicite :

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

Maintenant, cela fonctionne:

DoubleClass doubleObject = new DoubleClass();
FloatClass convertedObject = doubleObject;
2
Tim Schmelter