Refactorisation; créer des pseudo-primitives pour votre domaine d'application

Question

Comment referiez-vous cela en gardant à l'esprit que vous avez des douzaines de mesures de plus à représenter? C'est un peu comme changer un int pour court ou long ou octet. Unité générique? Conversion de type implicite par une surcharge de l'opérateur? ToType() pattern? Classe de base abstraite? IConvertible?

public class lb 
{ 
    private readonly float lbs; 
    private readonly kg kgs; 

    public lb(float lbs) 
    { 
     this.lbs = lbs; 
     this.kgs = new kg(lbs * 0.45359237F); 
    } 

    public kg ToKg() 
    { 
     return this.kgs; 
    } 

    public float ToFloat() 
    { 
     return this.lbs; 
    } 
} 

public class kg 
{ 
    private readonly float kgs; 
    private readonly lb lbs; 

    public kg(float kgs) 
    { 
     this.kgs = kgs; 
     this.lbs = new lb(kgs * 2.20462262F); 
    } 

    public float ToFloat() 
    { 
     return this.kgs; 
    } 

    public lb ToLb() 
    { 
     return this.lbs; 
    } 
} 

Answer 1

Je ne créerais pas de classes séparées pour chaque poids. Au lieu de cela, ont une classe qui représente une unité et un autre qui représente un certain nombre d'une unité:

/// <summary> 
/// Class representing a unit of weight, including how to 
/// convert that unit to kg. 
/// </summary> 
class WeightUnit 
{ 
    private readonly float conv; 
    private readonly string name; 

    /// <summary> 
    /// Creates a weight unit 
    /// </summary> 
    WeightUnit(float conv, string name) 
    { 
     this.conv = conv; 
     this.name = name; 
    } 

    /// <summary> 
    /// Returns the name of the unit 
    /// </summary> 
    public string Name { get { return name; } } 

    /// <summary> 
    /// Returns the multiplier used to convert this 
    /// unit into kg 
    /// </summary> 
    public float convToKg { get { return conv; } } 
}; 

/// <summary> 
/// Class representing a weight, i.e., a number and a unit. 
/// </summary> 
class Weight 
{ 
    private readonly float value; 
    private readonly WeightUnit unit; 

    public Weight(float value, WeightUnit unit) 
    { 
     this.value = value; 
     this.unit = unit; 
    } 

    public float ToFloat() 
    { 
     return value; 
    } 

    public WeightUnit Unit 
    { 
     get { return unit; } 
    } 

    /// <summary> 
    /// Creates a Weight object that is the same value 
    /// as this object, but in the given units. 
    /// </summary> 
    public Weight Convert(WeightUnit newUnit) 
    { 
     float newVal = value * unit.convToKg/newUnit.convToKg; 

     return new Weight(newVal, newUnit); 
    } 
}; 

La bonne chose ici est que vous pouvez créer tous les WeightUnits comme des objets singleton à partir des données, peut-être un fichier XML ou d'une ressource , de sorte que vous pouvez ajouter une nouvelle unité sans changer de code du tout. Créer un objet Weight est juste une question de recherche du singleton correct par son nom.

Answer 2

Je pense que je vais en faire un struct, que la plupart des primitives sont de toute façon.