public static TMeasurement Parse <TMeasurement>(double value, string type)
where TMeasurement : IMeasurement
{
var runtimeType = typeof(TMeasurement);
if (runtimeType == typeof(IEnergy))
{
return((TMeasurement)EnergyParser.Parse(value, type));
}
if (runtimeType == typeof(IPower))
{
return((TMeasurement)PowerParser.Parse(value, type));
}
if (runtimeType == typeof(IRatio))
{
return((TMeasurement)RatioParser.Parse(value, type));
}
if (runtimeType == typeof(ITemperature))
{
return((TMeasurement)TemperatureParser.Parse(value, type));
}
if (runtimeType == typeof(IHumidity))
{
return((TMeasurement)HumidityParser.Parse(value, type));
}
if (runtimeType == typeof(IIlluminance))
{
return((TMeasurement)IlluminanceParser.Parse(value, type));
}
if (runtimeType == typeof(IMeasurement))
{
return((TMeasurement)(IMeasurement) new ReadOnlyMeasurement(value, type));
}
throw new Exception("Could not determine type " + runtimeType.Name);
}
public override ITemperature GetValue()
{
var dataEntry = GetDataEntry();
if (dataEntry == null)
{
return(null);
}
var number = dataEntry.DecimalValue ?? 0;
var units = dataEntry.Units;
if (number == 0 && units == string.Empty)
{
return(null);
}
var result = TemperatureParser.Parse((double)number, units);
return(result);
}
public override void Execute()
{
bool calculateWindChill = false;
double windSpeed = 0.0;
//Tell the user which options are available.
Output.Add("--------------------------------------------------------------");
Output.Add("Temperatuur types: F (Farhenheit), C (Celsius), K (Kelvin).");
Output.Add("Zet de letter achter het nummer, hoofdletters maakt niet uit.");
Output.Add("--------------------------------------------------------------");
//Ask the user which value he wants to use for the conversion
AssignmentHelper.RequestInput(
this,
"Voer de temperatuur in die je wilt gebruiken. (bijv. 20.0C of 25.6F)",
out string inputString
);
bool parsed = TemperatureParser.Parse(inputString, out TemperatureUnit inputUnit, out double inputValue);
if (!parsed)
{
Error = $"Kan waarde `{inputString}` niet conventeren naar een double.";
return;
}
if (inputUnit == TemperatureUnit.Unknown)
{
Error = $"Onbekende temperatuur type!";
return;
}
// Ask the user which type he wants to convert to.
bool targetUnitSuccess = AssignmentHelper.RequestInput(
this,
"Naar welk temperatuur type wil je het conveteren (F/C/K)?",
out char targeUnitResult
);
if (!targetUnitSuccess)
{
Error = "Kan input niet converteren naar goede type.";
return;
}
TemperatureUnit targetUnit = (TemperatureUnit)targeUnitResult;
if (inputUnit.Equals(targetUnit))
{
Error = $"De conversie is het zelfde (van {inputUnit} naar {targetUnit})";
return;
}
ConsoleKey key = AssignmentHelper.RequestKey(
"Wil je ook het gevoelstemperatuur berekenen?",
new[] { ConsoleKey.Y, ConsoleKey.N }
);
if (key == ConsoleKey.Y)
{
AssignmentHelper.RequestInput <double>(
this,
"Wat is de wind snelheid in kilometer per seconde?",
out windSpeed
);
calculateWindChill = true;
}
else if (key == ConsoleKey.N)
{
calculateWindChill = false;
}
else
{
Error = "De ingevoerde toets is incorrect.";
return;
}
//Lookup conversion, print result
double result = TemperatureConverter.Convert(inputValue, inputUnit, targetUnit);
double resultRounded = Math.Round(result, 2);
StringBuilder builder = new StringBuilder();
builder.AppendLine("");
builder.AppendLine($"Het gegeven temperatuur was {inputValue} {inputUnit}, omgezet is het resultaat: {result} {targetUnit}");
builder.AppendLine("");
//Append the results of the wind chill calculations.
if (calculateWindChill)
{
double resultWindChill = TemperatureConverter.ConvertInclWindChill(inputValue, windSpeed, inputUnit, targetUnit);
double resultWindChillRounded = Math.Round(resultWindChill, 2);
builder.AppendLine($"Het gevoelstemperatuur met een windsnelheid van {windSpeed} km/h is {resultWindChillRounded} {targetUnit} \n");
}
//Write out the entire result.
Output.Add(builder.ToString());
Output.Add("Oant moan!");
}
public void ItParsesTheTypeProperly(string input, Type type)
{
var result = TemperatureParser.Parse(input);
Assert.That(result.GetType(), Is.EqualTo(type));
}
public void ItParsesTheValueProperly(string input, double expected)
{
var result = TemperatureParser.Parse(input);
Assert.That(result.Value, Is.EqualTo(expected));
}
public void ItThrowsAnExceptionWhenParsingInvalidTemperatures(string input)
{
TemperatureParser.Parse(input);
}
public void ItDoesNotThrowAnExceptionWhenParsingValidTemperatures(string input)
{
TemperatureParser.Parse(input);
}
public static ITemperature ToTemperature(this IParameter parameter)
{
return(TemperatureParser.Parse(parameter.Value));
}
