lenguaje - operador ? c#

¿Alternativa a escribir muchas declaraciones if?

Question

Aquí está mi método:

private void ConvertValues()  
{  
    txtResult.Text = angles[cmbUnits1.SelectedIndex];  
    double value1 = Convert.ToDouble(txtValue1.Text);  
    double value2 = Convert.ToDouble(txtValue2.Text);  
    int unit1 = cmbUnits1.SelectedIndex;  
}

Lo que quiero que el método haga es seleccionar los ComboBoxes y probar los valores. Pero quiero saber si hay una alternativa a esto:

if( angles[cmbUnits1.SelectedIndex].Equals("Degrees") && 
    angles[cmbUnits2.SelectedIndex].Equals("Radians")) {  
    ...  
}

Por cierto, estoy creando una especie de convertidor unitario, así que tendré secciones distintas a los ángulos. Así que me gustaría alguna enumeración, interfaz, clase abstracta o clase que pueda implementar. ¿Tal vez una clase con el nombre de Unidad? De modo que puedo crear nuevos objetos como Unit degrees = new Unit(Units.Angle) con unidades como una enumeración. O simplemente Unit sqrMillimeters = new Unit("Area"); ?

Answer 1

¿Hay alguna manera de que puedas escribir una instrucción switch lugar?

switch (something)
{
  case "degrees" : do work
  ...etc
}

Answer 2

¿Qué tal una combinación de SelectedIndexChanged / SelectedValueChanged Events y algún polimorfismo?

Answer 3

Puede concatenar ambas cadenas ("GradosRadios") y llamar a un Método llamado "GradosRadios" a través de Reflexión:

MethodInfo theMethod = thisType.GetMethod(methodName);
theMethod.Invoke(this, parameters);

Donde methodName son las cadenas concatenadas (tal vez con información adicional, como "convertir" + unidad1 + "2" + unidad2, como "convertDegrees2Radians"), y los parámetros es una matriz que contiene ambos valores.

Answer 4

double UnitToFactor(string unit) { returns 1 for radians, pi/180 for degrees, etc }

entonces

ratio = UnitToFactor(unit1) / UnitToFactor(unit2);

y dest = src*ratio

De esta manera, en lugar de declaraciones N ^ 2 if (), solo tienes N.

Answer 5

Claro, polimorfismo. Cada vez que vea instrucciones de conmutación largas o construcciones de / then / else, siempre será posible manejarlas usando polimorfismo y fábricas. En su caso, me imagino que una interfaz ITemperatureConverter con implementaciones concretas para Fahrenheit, Celcius, Kelvin y Rankine sería muy útil.

ACTUALIZAR:

Si encuentra que tiene esta lógica repetida, ¿por qué no tener una mejor abstracción para un ángulo que un doble?

Si escribe en un lenguaje orientado a objetos, es una buena idea superar las primitivas (por ejemplo, doble y sí, cadena) para encapsular el comportamiento en objetos.

Pensaría en una clase Angle que se aferraría al valor y lo devolvería como quisiera.

Esta es una forma de hacerlo en Java. Dejaré la traducción a C # y el resto para ti.

package angles;

public class Angle
{
    private double value;
    private AngleUnit units;

    public Angle()
    {
        this(0.0, AngleUnit.RADIANS);
    }

    public Angle(double value)
    {
        this(value, AngleUnit.RADIANS);
    }

    public Angle(double value, AngleUnit units)
    {
        this.value = value;
        this.units = units;
    }

    public double getValue()
    {
        return value;
    }

    public AngleUnit getUnits()
    {
        return units;
    }

    public Angle convert(AngleUnit newUnits)
    {
        Angle newAngle = null;

        if (this.units.equals(newUnits))
        {
            return this;
        }

        return newAngle;
    }
}

package angles;

public interface AngleConverter
{
    Angle convert(Angle angle, AngleUnit to);
}

package angles;

public enum AngleUnit
{
    DEGREES, RADIANS, GRADIANS;
}

package angles;

import java.util.HashMap;
import java.util.Map;

public class DegreeConverter implements AngleConverter
{
    private final Map<AngleUnit, Double> factors;

    public DegreeConverter(Map<AngleUnit, Double> factors)
    {
        this.factors = new HashMap<AngleUnit, Double>();
        this.factors.put(AngleUnit.DEGREES, 1.0);
        this.factors.put(AngleUnit.RADIANS, Math.PI/180.0);
        this.factors.put(AngleUnit.GRADIANS, 100.0/90.);
    }

    public Angle convert(Angle angle, AngleUnit to)
    {
        assert angle != null && to != null;

        return new Angle(angle.getValue()*this.factors.get(to), to);
    }
}