.NET units class, pulgadas a milímetros

Question

¿.NET tiene unidades de clase de conversión? Necesito convertir pulgadas a milímetros y viceversa.

Answer 1

No, no hay nada como eso incorporado. Pero puedes simplemente multiplicar o dividir por 25.4.

Answer 2

No, no hay tales conversiones de unidades integradas en el marco. Sin embargo, debería ser lo suficientemente fácil de implementarse usted mismo.

Answer 3

No, tiene que hacer uno mismo, de esta manera:

public class Length 
{ 
    private const double MillimetersPerInch = 25.4; 
    private double _Millimeters; 

    public static Length FromMillimeters(double mm) 
    { 
     return new Length { _Millimeters = mm }; 
    } 

    public static Length FromInch(double inch) 
    { 
     return new Length { _Millimeters = inch * MillimetersPerInch }; 
    } 

    public double Inch { get { return _Millimeters/MillimetersPerInch; } } 
    public double Millimeters { get { return _Millimeters; } } 
} 

Answer 4

.NET Framework no tiene nada como esto, pero lo hace F # Units of Measure.

Answer 5

Csunits es una buena biblioteca de unidades de medida para C#, consulte https://github.com/cureos/csunits. Actualmente está orientado a la radioterapia, pero puede agregar fácilmente sus propias unidades y cantidades.

Answer 6

He tratado este problema con anterioridad. Recomiendo hacer dos clases de distancia. Uno que tiene las medidas imperiales y otro que tiene las medidas métricas. Luego, puede convertir entre ellos fácilmente, con la obvia advertencia de que pierde precisión cuando lo hace.

Aquí hay un ejemplo de una clase de distancia imperial, con pulgadas como la unidad base de medida.

public class ImperialDistance { 

    public static readonly ImperialDistance Inch = new ImperialDistance(1.0); 
    public static readonly ImperialDistance Foot = new ImperialDistance(12.0); 
    public static readonly ImperialDistance Yard = new ImperialDistance(36.0); 
    public static readonly ImperialDistance Mile = new ImperialDistance(63360.0); 

    private double _inches; 

    public ImperialDistance(double inches) { 
     _inches = inches; 
    } 

    public double ToInches() { 
     return _inches; 
    } 

    public double ToFeet() { 
     return _inches/Foot._inches; 
    } 

    public double ToYards() { 
     return _inches/Yard._inches; 
    } 

    public double ToMiles() { 
     return _inches/Mile._inches; 
    } 

    public MetricDistance ToMetricDistance() { 
     return new MetricDistance(_inches * 0.0254); 
    } 

    public override int GetHashCode() { 
     return _inches.GetHashCode(); 
    } 

    public override bool Equals(object obj) { 
     var o = obj as ImperialDistance; 
     if (o == null) return false; 
     return _inches.Equals(o._inches); 
    } 

    public static bool operator ==(ImperialDistance a, ImperialDistance b) { 
     // If both are null, or both are same instance, return true 
     if (ReferenceEquals(a, b)) return true; 

     // if either one or the other are null, return false 
     if (ReferenceEquals(a, null) || ReferenceEquals(b, null)) return false; 

     // compare 
     return a._inches == b._inches; 
    } 

    public static bool operator !=(ImperialDistance a, ImperialDistance b) { 
     return !(a == b); 
    } 

    public static ImperialDistance operator +(ImperialDistance a, ImperialDistance b) { 
     if (a == null) throw new ArgumentNullException(); 
     if (b == null) throw new ArgumentNullException(); 
     return new ImperialDistance(a._inches + b._inches); 
    } 

    public static ImperialDistance operator -(ImperialDistance a, ImperialDistance b) { 
     if (a == null) throw new ArgumentNullException(); 
     if (b == null) throw new ArgumentNullException(); 
     return new ImperialDistance(a._inches - b._inches); 
    } 

    public static ImperialDistance operator *(ImperialDistance a, ImperialDistance b) { 
     if (a == null) throw new ArgumentNullException(); 
     if (b == null) throw new ArgumentNullException(); 
     return new ImperialDistance(a._inches * b._inches); 
    } 

    public static ImperialDistance operator /(ImperialDistance a, ImperialDistance b) { 
     if (a == null) throw new ArgumentNullException(); 
     if (b == null) throw new ArgumentNullException(); 
     return new ImperialDistance(a._inches/b._inches); 
    } 
} 

Y aquí es una clase métrica con metros como la unidad base:

public class MetricDistance { 

    public static readonly MetricDistance Milimeter = new MetricDistance(0.001); 
    public static readonly MetricDistance Centimeter = new MetricDistance(0.01); 
    public static readonly MetricDistance Decimeter = new MetricDistance(0.1); 
    public static readonly MetricDistance Meter = new MetricDistance(1.0); 
    public static readonly MetricDistance Decameter = new MetricDistance(10.0); 
    public static readonly MetricDistance Hectometer = new MetricDistance(100.0); 
    public static readonly MetricDistance Kilometer = new MetricDistance(1000.0); 

    private double _meters; 

    public MetricDistance(double meters) { 
     _meters = meters; 
    } 

    public double ToMilimeters() { 
     return _meters/Milimeter._meters; 
    } 

    public double ToCentimeters() { 
     return _meters/Centimeter._meters; 
    } 

    public double ToDecimeters() { 
     return _meters/Decimeter._meters; 
    } 

    public double ToMeters() { 
     return _meters; 
    } 

    public double ToDecameters() { 
     return _meters/Decameter._meters; 
    } 

    public double ToHectometers() { 
     return _meters/Hectometer._meters; 
    } 

    public double ToKilometers() { 
     return _meters/Kilometer._meters; 
    } 

    public ImperialDistance ToImperialDistance() { 
     return new ImperialDistance(_meters * 39.3701); 
    } 

    public override int GetHashCode() { 
     return _meters.GetHashCode(); 
    } 

    public override bool Equals(object obj) { 
     var o = obj as MetricDistance; 
     if (o == null) return false; 
     return _meters.Equals(o._meters); 
    } 

    public static bool operator ==(MetricDistance a, MetricDistance b) { 
     // If both are null, or both are same instance, return true 
     if (ReferenceEquals(a, b)) return true; 

     // if either one or the other are null, return false 
     if (ReferenceEquals(a, null) || ReferenceEquals(b, null)) return false; 

     return a._meters == b._meters; 
    } 

    public static bool operator !=(MetricDistance a, MetricDistance b) { 
     return !(a == b); 
    } 

    public static MetricDistance operator +(MetricDistance a, MetricDistance b) { 
     if (a == null) throw new ArgumentNullException("a"); 
     if (b == null) throw new ArgumentNullException("b"); 
     return new MetricDistance(a._meters + b._meters); 
    } 

    public static MetricDistance operator -(MetricDistance a, MetricDistance b) { 
     if (a == null) throw new ArgumentNullException("a"); 
     if (b == null) throw new ArgumentNullException("b"); 
     return new MetricDistance(a._meters - b._meters); 
    } 

    public static MetricDistance operator *(MetricDistance a, MetricDistance b) { 
     if (a == null) throw new ArgumentNullException("a"); 
     if (b == null) throw new ArgumentNullException("b"); 
     return new MetricDistance(a._meters * b._meters); 
    } 

    public static MetricDistance operator /(MetricDistance a, MetricDistance b) { 
     if (a == null) throw new ArgumentNullException("a"); 
     if (b == null) throw new ArgumentNullException("b"); 
     return new MetricDistance(a._meters/b._meters); 
    } 
} 

Y aquí es un método de prueba que ejemplifica el uso.

[TestMethod] 
public void _5in_Equals_12_7cm() { 
    var inches = new ImperialDistance(5); 
    var cms = new MetricDistance(MetricDistance.Centimeter.ToMeters() * 12.7); 
    var calcCentimeters = Math.Round(inches.ToMetricDistance().ToCentimeters(), 2, MidpointRounding.AwayFromZero); 
    var calcInches = Math.Round(cms.ToImperialDistance().ToInches(), 2, MidpointRounding.AwayFromZero); 

    Assert.AreEqual(cms.ToCentimeters(), 12.7); 
    Assert.AreEqual(calcCentimeters, 12.7); 
    Assert.AreEqual(inches.ToInches(), 5); 
    Assert.AreEqual(calcInches, 5); 
} 

También puede agregar métodos de extensión

public static MetricDistance Centimeters(this Int32 that) { 
    return new MetricDistance(MetricDistance.Centimeter.ToMeters() * that); 
} 

[TestMethod] 
public void _100cm_plus_300cm_equals_400cm() { 
    Assert.AreEqual(100.Centimeters() + 300.Centimeters(), 400.Centimeters()); 
} 

Puede utilizar esta sencilla estrategia de pesos, temperaturas, medidas de líquidos, etc.