diff --git a/UnitsNet.Tests/DummyIQuantity.cs b/UnitsNet.Tests/DummyIQuantity.cs new file mode 100644 index 0000000000..04f97a7ea2 --- /dev/null +++ b/UnitsNet.Tests/DummyIQuantity.cs @@ -0,0 +1,60 @@ +using System; +using System.Collections.Generic; +using System.Text; +using JetBrains.Annotations; + +namespace UnitsNet.Tests +{ + internal class DummyIQuantity : IQuantity + { + public QuantityType Type => throw new NotImplementedException(); + + public BaseDimensions Dimensions => throw new NotImplementedException(); + + public QuantityInfo QuantityInfo => throw new NotImplementedException(); + + public Enum Unit => throw new NotImplementedException(); + + public double Value => throw new NotImplementedException(); + + public double As(Enum unit) + { + throw new NotImplementedException(); + } + + public double As(UnitSystem unitSystem) + { + throw new NotImplementedException(); + } + + public string ToString([CanBeNull] IFormatProvider provider) + { + throw new NotImplementedException(); + } + + public string ToString([CanBeNull] IFormatProvider provider, int significantDigitsAfterRadix) + { + throw new NotImplementedException(); + } + + public string ToString([CanBeNull] IFormatProvider provider, [NotNull] string format, [NotNull] params object[] args) + { + throw new NotImplementedException(); + } + + public string ToString(string format, IFormatProvider formatProvider) + { + throw new NotImplementedException(); + } + + public IQuantity ToUnit(Enum unit) + { + throw new NotImplementedException(); + } + + public IQuantity ToUnit(UnitSystem unitSystem) + { + throw new NotImplementedException(); + } + } +} diff --git a/UnitsNet.Tests/QuantityTest.cs b/UnitsNet.Tests/QuantityTest.cs index fa7c7ac9cd..215b22e7ba 100644 --- a/UnitsNet.Tests/QuantityTest.cs +++ b/UnitsNet.Tests/QuantityTest.cs @@ -4,6 +4,7 @@ using System; using System.Globalization; using System.Linq; +using JetBrains.Annotations; using UnitsNet.Units; using Xunit; @@ -135,6 +136,13 @@ public void TryFrom_GivenValueAndUnit_ReturnsQuantity() Assert.Equal(Pressure.FromMegabars(3), parsedPressure); } + [Fact] + public void TryParse_GivenInvalidQuantityType_ReturnsFalseAndNullQuantity() + { + Assert.False(Quantity.TryParse(typeof(DummyIQuantity), "3.0 cm", out IQuantity parsedLength)); + Assert.Null(parsedLength); + } + [Fact] public void TryParse_GivenInvalidString_ReturnsFalseAndNullQuantity() { @@ -171,5 +179,27 @@ public void Types_ReturnsKnownQuantityTypes() Assert.Superset(knownQuantities.ToHashSet(), types.ToHashSet()); Assert.Equal(QuantityCount, types.Length); } + + [Fact] + public void FromQuantityType_GivenUndefinedQuantityType_ThrowsArgumentException() + { + Assert.Throws(() => Quantity.FromQuantityType(QuantityType.Undefined, 0.0)); + } + + [Fact] + public void FromQuantityType_GivenInvalidQuantityType_ThrowsArgumentException() + { + Assert.Throws(() => Quantity.FromQuantityType((QuantityType)(-1), 0.0)); + } + + [Fact] + public void FromQuantityType_GivenLengthQuantityType_ReturnsLengthQuantity() + { + var fromQuantity = Quantity.FromQuantityType(QuantityType.Length, 0.0); + + Assert.Equal(0.0, fromQuantity.Value); + Assert.Equal(QuantityType.Length, fromQuantity.Type); + Assert.Equal(Length.BaseUnit, fromQuantity.Unit); + } } } diff --git a/UnitsNet/CustomCode/Quantity.cs b/UnitsNet/CustomCode/Quantity.cs index fb2fd7423f..74fe89d86d 100644 --- a/UnitsNet/CustomCode/Quantity.cs +++ b/UnitsNet/CustomCode/Quantity.cs @@ -1,6 +1,8 @@ using System; using System.Collections.Generic; +using System.Globalization; using System.Linq; +using JetBrains.Annotations; using UnitsNet.InternalHelpers; namespace UnitsNet @@ -15,17 +17,9 @@ static Quantity() Types = quantityTypes; Names = quantityTypes.Select(qt => qt.ToString()).ToArray(); - // A bunch of reflection to enumerate quantity types, instantiate with the default constructor and return its QuantityInfo property - InfosLazy = new Lazy(() => typeof(Length) - .Wrap() - .Assembly - .GetExportedTypes() - .Where(typeof(IQuantity).IsAssignableFrom) - .Where(t => t.Wrap().IsClass || t.Wrap().IsValueType) // Future-proofing: Considering changing quantities from struct to class - .Select(Activator.CreateInstance) - .Cast() - .Select(q => q.QuantityInfo) - .OrderBy(q => q.Name) + InfosLazy = new Lazy(() => Types + .Select(quantityType => FromQuantityType(quantityType, 0.0).QuantityInfo) + .OrderBy(quantityInfo => quantityInfo.Name) .ToArray()); } @@ -60,6 +54,55 @@ public static IQuantity From(QuantityValue value, Enum unit) $"Unit value {unit} of type {unit.GetType()} is not a known unit enum type. Expected types like UnitsNet.Units.LengthUnit. Did you pass in a third-party enum type defined outside UnitsNet library?"); } + /// + public static bool TryFrom(double value, Enum unit, out IQuantity quantity) + { + // Implicit cast to QuantityValue would prevent TryFrom from being called, + // so we need to explicitly check this here for double arguments. + if (double.IsNaN(value) || double.IsInfinity(value)) + { + quantity = default(IQuantity); + return false; + } + + return TryFrom((QuantityValue)value, unit, out quantity); + } + + /// + public static IQuantity Parse(Type quantityType, string quantityString) => Parse(null, quantityType, quantityString); + + /// + /// Dynamically parse a quantity string representation. + /// + /// The format provider to use for lookup. Defaults to if null. + /// Type of quantity, such as . + /// Quantity string representation, such as "1.5 kg". Must be compatible with given quantity type. + /// The parsed quantity. + /// Type must be of type UnitsNet.IQuantity -or- Type is not a known quantity type. + public static IQuantity Parse([CanBeNull] IFormatProvider formatProvider, Type quantityType, string quantityString) + { + if (!typeof(IQuantity).Wrap().IsAssignableFrom(quantityType)) + throw new ArgumentException($"Type {quantityType} must be of type UnitsNet.IQuantity."); + + if (TryParse(formatProvider, quantityType, quantityString, out IQuantity quantity)) return quantity; + + throw new ArgumentException($"Quantity string could not be parsed to quantity {quantityType}."); + } + + /// + public static bool TryParse(Type quantityType, string quantityString, out IQuantity quantity) => + TryParse(null, quantityType, quantityString, out quantity); + + /// + /// Get information about the given quantity type. + /// + /// The quantity type enum value. + /// Information about the quantity and its units. + public static QuantityInfo GetInfo(QuantityType quantityType) + { + return Infos.First(qi => qi.QuantityType == quantityType); + } + /// /// Get a list of quantities that has the given base dimensions. /// diff --git a/UnitsNet/GeneratedCode/Quantity.g.cs b/UnitsNet/GeneratedCode/Quantity.g.cs index ce8e9d18c3..25f1546c97 100644 --- a/UnitsNet/GeneratedCode/Quantity.g.cs +++ b/UnitsNet/GeneratedCode/Quantity.g.cs @@ -19,7 +19,6 @@ using System; using System.Globalization; -using System.Linq; using JetBrains.Annotations; using UnitsNet.InternalHelpers; using UnitsNet.Units; @@ -31,18 +30,199 @@ namespace UnitsNet /// public static partial class Quantity { - /// - public static bool TryFrom(double value, Enum unit, out IQuantity quantity) + /// + /// Dynamically constructs a quantity of the given with the value in the quantity's base units. + /// + /// The of the quantity to create. + /// The value to construct the quantity with. + /// The created quantity. + public static IQuantity FromQuantityType(QuantityType quantityType, QuantityValue value) { - // Implicit cast to QuantityValue would prevent TryFrom from being called, - // so we need to explicitly check this here for double arguments. - if (double.IsNaN(value) || double.IsInfinity(value)) + switch(quantityType) { - quantity = default(IQuantity); - return false; + case QuantityType.Acceleration: + return Acceleration.From(value, Acceleration.BaseUnit); + case QuantityType.AmountOfSubstance: + return AmountOfSubstance.From(value, AmountOfSubstance.BaseUnit); + case QuantityType.AmplitudeRatio: + return AmplitudeRatio.From(value, AmplitudeRatio.BaseUnit); + case QuantityType.Angle: + return Angle.From(value, Angle.BaseUnit); + case QuantityType.ApparentEnergy: + return ApparentEnergy.From(value, ApparentEnergy.BaseUnit); + case QuantityType.ApparentPower: + return ApparentPower.From(value, ApparentPower.BaseUnit); + case QuantityType.Area: + return Area.From(value, Area.BaseUnit); + case QuantityType.AreaDensity: + return AreaDensity.From(value, AreaDensity.BaseUnit); + case QuantityType.AreaMomentOfInertia: + return AreaMomentOfInertia.From(value, AreaMomentOfInertia.BaseUnit); + case QuantityType.BitRate: + return BitRate.From(value, BitRate.BaseUnit); + case QuantityType.BrakeSpecificFuelConsumption: + return BrakeSpecificFuelConsumption.From(value, BrakeSpecificFuelConsumption.BaseUnit); + case QuantityType.Capacitance: + return Capacitance.From(value, Capacitance.BaseUnit); + case QuantityType.CoefficientOfThermalExpansion: + return CoefficientOfThermalExpansion.From(value, CoefficientOfThermalExpansion.BaseUnit); + case QuantityType.Density: + return Density.From(value, Density.BaseUnit); + case QuantityType.Duration: + return Duration.From(value, Duration.BaseUnit); + case QuantityType.DynamicViscosity: + return DynamicViscosity.From(value, DynamicViscosity.BaseUnit); + case QuantityType.ElectricAdmittance: + return ElectricAdmittance.From(value, ElectricAdmittance.BaseUnit); + case QuantityType.ElectricCharge: + return ElectricCharge.From(value, ElectricCharge.BaseUnit); + case QuantityType.ElectricChargeDensity: + return ElectricChargeDensity.From(value, ElectricChargeDensity.BaseUnit); + case QuantityType.ElectricConductance: + return ElectricConductance.From(value, ElectricConductance.BaseUnit); + case QuantityType.ElectricConductivity: + return ElectricConductivity.From(value, ElectricConductivity.BaseUnit); + case QuantityType.ElectricCurrent: + return ElectricCurrent.From(value, ElectricCurrent.BaseUnit); + case QuantityType.ElectricCurrentDensity: + return ElectricCurrentDensity.From(value, ElectricCurrentDensity.BaseUnit); + case QuantityType.ElectricCurrentGradient: + return ElectricCurrentGradient.From(value, ElectricCurrentGradient.BaseUnit); + case QuantityType.ElectricField: + return ElectricField.From(value, ElectricField.BaseUnit); + case QuantityType.ElectricInductance: + return ElectricInductance.From(value, ElectricInductance.BaseUnit); + case QuantityType.ElectricPotential: + return ElectricPotential.From(value, ElectricPotential.BaseUnit); + case QuantityType.ElectricPotentialAc: + return ElectricPotentialAc.From(value, ElectricPotentialAc.BaseUnit); + case QuantityType.ElectricPotentialDc: + return ElectricPotentialDc.From(value, ElectricPotentialDc.BaseUnit); + case QuantityType.ElectricResistance: + return ElectricResistance.From(value, ElectricResistance.BaseUnit); + case QuantityType.ElectricResistivity: + return ElectricResistivity.From(value, ElectricResistivity.BaseUnit); + case QuantityType.Energy: + return Energy.From(value, Energy.BaseUnit); + case QuantityType.Entropy: + return Entropy.From(value, Entropy.BaseUnit); + case QuantityType.Force: + return Force.From(value, Force.BaseUnit); + case QuantityType.ForceChangeRate: + return ForceChangeRate.From(value, ForceChangeRate.BaseUnit); + case QuantityType.ForcePerLength: + return ForcePerLength.From(value, ForcePerLength.BaseUnit); + case QuantityType.Frequency: + return Frequency.From(value, Frequency.BaseUnit); + case QuantityType.HeatFlux: + return HeatFlux.From(value, HeatFlux.BaseUnit); + case QuantityType.HeatTransferCoefficient: + return HeatTransferCoefficient.From(value, HeatTransferCoefficient.BaseUnit); + case QuantityType.Illuminance: + return Illuminance.From(value, Illuminance.BaseUnit); + case QuantityType.Information: + return Information.From(value, Information.BaseUnit); + case QuantityType.Irradiance: + return Irradiance.From(value, Irradiance.BaseUnit); + case QuantityType.Irradiation: + return Irradiation.From(value, Irradiation.BaseUnit); + case QuantityType.KinematicViscosity: + return KinematicViscosity.From(value, KinematicViscosity.BaseUnit); + case QuantityType.LapseRate: + return LapseRate.From(value, LapseRate.BaseUnit); + case QuantityType.Length: + return Length.From(value, Length.BaseUnit); + case QuantityType.Level: + return Level.From(value, Level.BaseUnit); + case QuantityType.LinearDensity: + return LinearDensity.From(value, LinearDensity.BaseUnit); + case QuantityType.LuminousFlux: + return LuminousFlux.From(value, LuminousFlux.BaseUnit); + case QuantityType.LuminousIntensity: + return LuminousIntensity.From(value, LuminousIntensity.BaseUnit); + case QuantityType.MagneticField: + return MagneticField.From(value, MagneticField.BaseUnit); + case QuantityType.MagneticFlux: + return MagneticFlux.From(value, MagneticFlux.BaseUnit); + case QuantityType.Magnetization: + return Magnetization.From(value, Magnetization.BaseUnit); + case QuantityType.Mass: + return Mass.From(value, Mass.BaseUnit); + case QuantityType.MassFlow: + return MassFlow.From(value, MassFlow.BaseUnit); + case QuantityType.MassFlux: + return MassFlux.From(value, MassFlux.BaseUnit); + case QuantityType.MassMomentOfInertia: + return MassMomentOfInertia.From(value, MassMomentOfInertia.BaseUnit); + case QuantityType.MolarEnergy: + return MolarEnergy.From(value, MolarEnergy.BaseUnit); + case QuantityType.MolarEntropy: + return MolarEntropy.From(value, MolarEntropy.BaseUnit); + case QuantityType.Molarity: + return Molarity.From(value, Molarity.BaseUnit); + case QuantityType.MolarMass: + return MolarMass.From(value, MolarMass.BaseUnit); + case QuantityType.Permeability: + return Permeability.From(value, Permeability.BaseUnit); + case QuantityType.Permittivity: + return Permittivity.From(value, Permittivity.BaseUnit); + case QuantityType.Power: + return Power.From(value, Power.BaseUnit); + case QuantityType.PowerDensity: + return PowerDensity.From(value, PowerDensity.BaseUnit); + case QuantityType.PowerRatio: + return PowerRatio.From(value, PowerRatio.BaseUnit); + case QuantityType.Pressure: + return Pressure.From(value, Pressure.BaseUnit); + case QuantityType.PressureChangeRate: + return PressureChangeRate.From(value, PressureChangeRate.BaseUnit); + case QuantityType.Ratio: + return Ratio.From(value, Ratio.BaseUnit); + case QuantityType.ReactiveEnergy: + return ReactiveEnergy.From(value, ReactiveEnergy.BaseUnit); + case QuantityType.ReactivePower: + return ReactivePower.From(value, ReactivePower.BaseUnit); + case QuantityType.RotationalAcceleration: + return RotationalAcceleration.From(value, RotationalAcceleration.BaseUnit); + case QuantityType.RotationalSpeed: + return RotationalSpeed.From(value, RotationalSpeed.BaseUnit); + case QuantityType.RotationalStiffness: + return RotationalStiffness.From(value, RotationalStiffness.BaseUnit); + case QuantityType.RotationalStiffnessPerLength: + return RotationalStiffnessPerLength.From(value, RotationalStiffnessPerLength.BaseUnit); + case QuantityType.SolidAngle: + return SolidAngle.From(value, SolidAngle.BaseUnit); + case QuantityType.SpecificEnergy: + return SpecificEnergy.From(value, SpecificEnergy.BaseUnit); + case QuantityType.SpecificEntropy: + return SpecificEntropy.From(value, SpecificEntropy.BaseUnit); + case QuantityType.SpecificVolume: + return SpecificVolume.From(value, SpecificVolume.BaseUnit); + case QuantityType.SpecificWeight: + return SpecificWeight.From(value, SpecificWeight.BaseUnit); + case QuantityType.Speed: + return Speed.From(value, Speed.BaseUnit); + case QuantityType.Temperature: + return Temperature.From(value, Temperature.BaseUnit); + case QuantityType.TemperatureChangeRate: + return TemperatureChangeRate.From(value, TemperatureChangeRate.BaseUnit); + case QuantityType.TemperatureDelta: + return TemperatureDelta.From(value, TemperatureDelta.BaseUnit); + case QuantityType.ThermalConductivity: + return ThermalConductivity.From(value, ThermalConductivity.BaseUnit); + case QuantityType.ThermalResistance: + return ThermalResistance.From(value, ThermalResistance.BaseUnit); + case QuantityType.Torque: + return Torque.From(value, Torque.BaseUnit); + case QuantityType.VitaminA: + return VitaminA.From(value, VitaminA.BaseUnit); + case QuantityType.Volume: + return Volume.From(value, Volume.BaseUnit); + case QuantityType.VolumeFlow: + return VolumeFlow.From(value, VolumeFlow.BaseUnit); + default: + throw new ArgumentException($"{quantityType} is not a supported quantity type."); } - - return TryFrom((QuantityValue) value, unit, out quantity); } /// @@ -334,31 +514,6 @@ public static bool TryFrom(QuantityValue value, Enum unit, out IQuantity quantit } } - /// - public static IQuantity Parse(Type quantityType, string quantityString) => Parse(null, quantityType, quantityString); - - /// - /// Dynamically parse a quantity string representation. - /// - /// The format provider to use for lookup. Defaults to if null. - /// Type of quantity, such as . - /// Quantity string representation, such as "1.5 kg". Must be compatible with given quantity type. - /// The parsed quantity. - /// Type must be of type UnitsNet.IQuantity -or- Type is not a known quantity type. - public static IQuantity Parse([CanBeNull] IFormatProvider formatProvider, Type quantityType, string quantityString) - { - if (!typeof(IQuantity).Wrap().IsAssignableFrom(quantityType)) - throw new ArgumentException($"Type {quantityType} must be of type UnitsNet.IQuantity."); - - if (TryParse(formatProvider, quantityType, quantityString, out IQuantity quantity)) return quantity; - - throw new ArgumentException($"Quantity string could not be parsed to quantity {quantityType}."); - } - - /// - public static bool TryParse(Type quantityType, string quantityString, out IQuantity quantity) => - TryParse(null, quantityType, quantityString, out quantity); - /// /// Try to dynamically parse a quantity string representation. /// @@ -376,288 +531,191 @@ public static bool TryParse([CanBeNull] IFormatProvider formatProvider, Type qua var parser = QuantityParser.Default; - if (quantityType == typeof(Acceleration)) - return parser.TryParse(quantityString, formatProvider, Acceleration.From, out quantity); - - if (quantityType == typeof(AmountOfSubstance)) - return parser.TryParse(quantityString, formatProvider, AmountOfSubstance.From, out quantity); - - if (quantityType == typeof(AmplitudeRatio)) - return parser.TryParse(quantityString, formatProvider, AmplitudeRatio.From, out quantity); - - if (quantityType == typeof(Angle)) - return parser.TryParse(quantityString, formatProvider, Angle.From, out quantity); - - if (quantityType == typeof(ApparentEnergy)) - return parser.TryParse(quantityString, formatProvider, ApparentEnergy.From, out quantity); - - if (quantityType == typeof(ApparentPower)) - return parser.TryParse(quantityString, formatProvider, ApparentPower.From, out quantity); - - if (quantityType == typeof(Area)) - return parser.TryParse(quantityString, formatProvider, Area.From, out quantity); - - if (quantityType == typeof(AreaDensity)) - return parser.TryParse(quantityString, formatProvider, AreaDensity.From, out quantity); - - if (quantityType == typeof(AreaMomentOfInertia)) - return parser.TryParse(quantityString, formatProvider, AreaMomentOfInertia.From, out quantity); - - if (quantityType == typeof(BitRate)) - return parser.TryParse(quantityString, formatProvider, BitRate.From, out quantity); - - if (quantityType == typeof(BrakeSpecificFuelConsumption)) - return parser.TryParse(quantityString, formatProvider, BrakeSpecificFuelConsumption.From, out quantity); - - if (quantityType == typeof(Capacitance)) - return parser.TryParse(quantityString, formatProvider, Capacitance.From, out quantity); - - if (quantityType == typeof(CoefficientOfThermalExpansion)) - return parser.TryParse(quantityString, formatProvider, CoefficientOfThermalExpansion.From, out quantity); - - if (quantityType == typeof(Density)) - return parser.TryParse(quantityString, formatProvider, Density.From, out quantity); - - if (quantityType == typeof(Duration)) - return parser.TryParse(quantityString, formatProvider, Duration.From, out quantity); - - if (quantityType == typeof(DynamicViscosity)) - return parser.TryParse(quantityString, formatProvider, DynamicViscosity.From, out quantity); - - if (quantityType == typeof(ElectricAdmittance)) - return parser.TryParse(quantityString, formatProvider, ElectricAdmittance.From, out quantity); - - if (quantityType == typeof(ElectricCharge)) - return parser.TryParse(quantityString, formatProvider, ElectricCharge.From, out quantity); - - if (quantityType == typeof(ElectricChargeDensity)) - return parser.TryParse(quantityString, formatProvider, ElectricChargeDensity.From, out quantity); - - if (quantityType == typeof(ElectricConductance)) - return parser.TryParse(quantityString, formatProvider, ElectricConductance.From, out quantity); - - if (quantityType == typeof(ElectricConductivity)) - return parser.TryParse(quantityString, formatProvider, ElectricConductivity.From, out quantity); - - if (quantityType == typeof(ElectricCurrent)) - return parser.TryParse(quantityString, formatProvider, ElectricCurrent.From, out quantity); - - if (quantityType == typeof(ElectricCurrentDensity)) - return parser.TryParse(quantityString, formatProvider, ElectricCurrentDensity.From, out quantity); - - if (quantityType == typeof(ElectricCurrentGradient)) - return parser.TryParse(quantityString, formatProvider, ElectricCurrentGradient.From, out quantity); - - if (quantityType == typeof(ElectricField)) - return parser.TryParse(quantityString, formatProvider, ElectricField.From, out quantity); - - if (quantityType == typeof(ElectricInductance)) - return parser.TryParse(quantityString, formatProvider, ElectricInductance.From, out quantity); - - if (quantityType == typeof(ElectricPotential)) - return parser.TryParse(quantityString, formatProvider, ElectricPotential.From, out quantity); - - if (quantityType == typeof(ElectricPotentialAc)) - return parser.TryParse(quantityString, formatProvider, ElectricPotentialAc.From, out quantity); - - if (quantityType == typeof(ElectricPotentialDc)) - return parser.TryParse(quantityString, formatProvider, ElectricPotentialDc.From, out quantity); - - if (quantityType == typeof(ElectricResistance)) - return parser.TryParse(quantityString, formatProvider, ElectricResistance.From, out quantity); - - if (quantityType == typeof(ElectricResistivity)) - return parser.TryParse(quantityString, formatProvider, ElectricResistivity.From, out quantity); - - if (quantityType == typeof(Energy)) - return parser.TryParse(quantityString, formatProvider, Energy.From, out quantity); - - if (quantityType == typeof(Entropy)) - return parser.TryParse(quantityString, formatProvider, Entropy.From, out quantity); - - if (quantityType == typeof(Force)) - return parser.TryParse(quantityString, formatProvider, Force.From, out quantity); - - if (quantityType == typeof(ForceChangeRate)) - return parser.TryParse(quantityString, formatProvider, ForceChangeRate.From, out quantity); - - if (quantityType == typeof(ForcePerLength)) - return parser.TryParse(quantityString, formatProvider, ForcePerLength.From, out quantity); - - if (quantityType == typeof(Frequency)) - return parser.TryParse(quantityString, formatProvider, Frequency.From, out quantity); - - if (quantityType == typeof(HeatFlux)) - return parser.TryParse(quantityString, formatProvider, HeatFlux.From, out quantity); - - if (quantityType == typeof(HeatTransferCoefficient)) - return parser.TryParse(quantityString, formatProvider, HeatTransferCoefficient.From, out quantity); - - if (quantityType == typeof(Illuminance)) - return parser.TryParse(quantityString, formatProvider, Illuminance.From, out quantity); - - if (quantityType == typeof(Information)) - return parser.TryParse(quantityString, formatProvider, Information.From, out quantity); - - if (quantityType == typeof(Irradiance)) - return parser.TryParse(quantityString, formatProvider, Irradiance.From, out quantity); - - if (quantityType == typeof(Irradiation)) - return parser.TryParse(quantityString, formatProvider, Irradiation.From, out quantity); - - if (quantityType == typeof(KinematicViscosity)) - return parser.TryParse(quantityString, formatProvider, KinematicViscosity.From, out quantity); - - if (quantityType == typeof(LapseRate)) - return parser.TryParse(quantityString, formatProvider, LapseRate.From, out quantity); - - if (quantityType == typeof(Length)) - return parser.TryParse(quantityString, formatProvider, Length.From, out quantity); - - if (quantityType == typeof(Level)) - return parser.TryParse(quantityString, formatProvider, Level.From, out quantity); - - if (quantityType == typeof(LinearDensity)) - return parser.TryParse(quantityString, formatProvider, LinearDensity.From, out quantity); - - if (quantityType == typeof(LuminousFlux)) - return parser.TryParse(quantityString, formatProvider, LuminousFlux.From, out quantity); - - if (quantityType == typeof(LuminousIntensity)) - return parser.TryParse(quantityString, formatProvider, LuminousIntensity.From, out quantity); - - if (quantityType == typeof(MagneticField)) - return parser.TryParse(quantityString, formatProvider, MagneticField.From, out quantity); - - if (quantityType == typeof(MagneticFlux)) - return parser.TryParse(quantityString, formatProvider, MagneticFlux.From, out quantity); - - if (quantityType == typeof(Magnetization)) - return parser.TryParse(quantityString, formatProvider, Magnetization.From, out quantity); - - if (quantityType == typeof(Mass)) - return parser.TryParse(quantityString, formatProvider, Mass.From, out quantity); - - if (quantityType == typeof(MassFlow)) - return parser.TryParse(quantityString, formatProvider, MassFlow.From, out quantity); - - if (quantityType == typeof(MassFlux)) - return parser.TryParse(quantityString, formatProvider, MassFlux.From, out quantity); - - if (quantityType == typeof(MassMomentOfInertia)) - return parser.TryParse(quantityString, formatProvider, MassMomentOfInertia.From, out quantity); - - if (quantityType == typeof(MolarEnergy)) - return parser.TryParse(quantityString, formatProvider, MolarEnergy.From, out quantity); - - if (quantityType == typeof(MolarEntropy)) - return parser.TryParse(quantityString, formatProvider, MolarEntropy.From, out quantity); - - if (quantityType == typeof(Molarity)) - return parser.TryParse(quantityString, formatProvider, Molarity.From, out quantity); - - if (quantityType == typeof(MolarMass)) - return parser.TryParse(quantityString, formatProvider, MolarMass.From, out quantity); - - if (quantityType == typeof(Permeability)) - return parser.TryParse(quantityString, formatProvider, Permeability.From, out quantity); - - if (quantityType == typeof(Permittivity)) - return parser.TryParse(quantityString, formatProvider, Permittivity.From, out quantity); - - if (quantityType == typeof(Power)) - return parser.TryParse(quantityString, formatProvider, Power.From, out quantity); - - if (quantityType == typeof(PowerDensity)) - return parser.TryParse(quantityString, formatProvider, PowerDensity.From, out quantity); - - if (quantityType == typeof(PowerRatio)) - return parser.TryParse(quantityString, formatProvider, PowerRatio.From, out quantity); - - if (quantityType == typeof(Pressure)) - return parser.TryParse(quantityString, formatProvider, Pressure.From, out quantity); - - if (quantityType == typeof(PressureChangeRate)) - return parser.TryParse(quantityString, formatProvider, PressureChangeRate.From, out quantity); - - if (quantityType == typeof(Ratio)) - return parser.TryParse(quantityString, formatProvider, Ratio.From, out quantity); - - if (quantityType == typeof(ReactiveEnergy)) - return parser.TryParse(quantityString, formatProvider, ReactiveEnergy.From, out quantity); - - if (quantityType == typeof(ReactivePower)) - return parser.TryParse(quantityString, formatProvider, ReactivePower.From, out quantity); - - if (quantityType == typeof(RotationalAcceleration)) - return parser.TryParse(quantityString, formatProvider, RotationalAcceleration.From, out quantity); - - if (quantityType == typeof(RotationalSpeed)) - return parser.TryParse(quantityString, formatProvider, RotationalSpeed.From, out quantity); - - if (quantityType == typeof(RotationalStiffness)) - return parser.TryParse(quantityString, formatProvider, RotationalStiffness.From, out quantity); - - if (quantityType == typeof(RotationalStiffnessPerLength)) - return parser.TryParse(quantityString, formatProvider, RotationalStiffnessPerLength.From, out quantity); - - if (quantityType == typeof(SolidAngle)) - return parser.TryParse(quantityString, formatProvider, SolidAngle.From, out quantity); - - if (quantityType == typeof(SpecificEnergy)) - return parser.TryParse(quantityString, formatProvider, SpecificEnergy.From, out quantity); - - if (quantityType == typeof(SpecificEntropy)) - return parser.TryParse(quantityString, formatProvider, SpecificEntropy.From, out quantity); - - if (quantityType == typeof(SpecificVolume)) - return parser.TryParse(quantityString, formatProvider, SpecificVolume.From, out quantity); - - if (quantityType == typeof(SpecificWeight)) - return parser.TryParse(quantityString, formatProvider, SpecificWeight.From, out quantity); - - if (quantityType == typeof(Speed)) - return parser.TryParse(quantityString, formatProvider, Speed.From, out quantity); - - if (quantityType == typeof(Temperature)) - return parser.TryParse(quantityString, formatProvider, Temperature.From, out quantity); - - if (quantityType == typeof(TemperatureChangeRate)) - return parser.TryParse(quantityString, formatProvider, TemperatureChangeRate.From, out quantity); - - if (quantityType == typeof(TemperatureDelta)) - return parser.TryParse(quantityString, formatProvider, TemperatureDelta.From, out quantity); - - if (quantityType == typeof(ThermalConductivity)) - return parser.TryParse(quantityString, formatProvider, ThermalConductivity.From, out quantity); - - if (quantityType == typeof(ThermalResistance)) - return parser.TryParse(quantityString, formatProvider, ThermalResistance.From, out quantity); - - if (quantityType == typeof(Torque)) - return parser.TryParse(quantityString, formatProvider, Torque.From, out quantity); - - if (quantityType == typeof(VitaminA)) - return parser.TryParse(quantityString, formatProvider, VitaminA.From, out quantity); - - if (quantityType == typeof(Volume)) - return parser.TryParse(quantityString, formatProvider, Volume.From, out quantity); - - if (quantityType == typeof(VolumeFlow)) - return parser.TryParse(quantityString, formatProvider, VolumeFlow.From, out quantity); - - throw new ArgumentException( - $"Type {quantityType} is not a known quantity type. Did you pass in a third-party quantity type defined outside UnitsNet library?"); - } - - /// - /// Get information about the given quantity type. - /// - /// The quantity type enum value. - /// Information about the quantity and its units. - public static QuantityInfo GetInfo(QuantityType quantityType) - { - return Infos.First(qi => qi.QuantityType == quantityType); + switch(quantityType) + { + case Type _ when quantityType == typeof(Acceleration): + return parser.TryParse(quantityString, formatProvider, Acceleration.From, out quantity); + case Type _ when quantityType == typeof(AmountOfSubstance): + return parser.TryParse(quantityString, formatProvider, AmountOfSubstance.From, out quantity); + case Type _ when quantityType == typeof(AmplitudeRatio): + return parser.TryParse(quantityString, formatProvider, AmplitudeRatio.From, out quantity); + case Type _ when quantityType == typeof(Angle): + return parser.TryParse(quantityString, formatProvider, Angle.From, out quantity); + case Type _ when quantityType == typeof(ApparentEnergy): + return parser.TryParse(quantityString, formatProvider, ApparentEnergy.From, out quantity); + case Type _ when quantityType == typeof(ApparentPower): + return parser.TryParse(quantityString, formatProvider, ApparentPower.From, out quantity); + case Type _ when quantityType == typeof(Area): + return parser.TryParse(quantityString, formatProvider, Area.From, out quantity); + case Type _ when quantityType == typeof(AreaDensity): + return parser.TryParse(quantityString, formatProvider, AreaDensity.From, out quantity); + case Type _ when quantityType == typeof(AreaMomentOfInertia): + return parser.TryParse(quantityString, formatProvider, AreaMomentOfInertia.From, out quantity); + case Type _ when quantityType == typeof(BitRate): + return parser.TryParse(quantityString, formatProvider, BitRate.From, out quantity); + case Type _ when quantityType == typeof(BrakeSpecificFuelConsumption): + return parser.TryParse(quantityString, formatProvider, BrakeSpecificFuelConsumption.From, out quantity); + case Type _ when quantityType == typeof(Capacitance): + return parser.TryParse(quantityString, formatProvider, Capacitance.From, out quantity); + case Type _ when quantityType == typeof(CoefficientOfThermalExpansion): + return parser.TryParse(quantityString, formatProvider, CoefficientOfThermalExpansion.From, out quantity); + case Type _ when quantityType == typeof(Density): + return parser.TryParse(quantityString, formatProvider, Density.From, out quantity); + case Type _ when quantityType == typeof(Duration): + return parser.TryParse(quantityString, formatProvider, Duration.From, out quantity); + case Type _ when quantityType == typeof(DynamicViscosity): + return parser.TryParse(quantityString, formatProvider, DynamicViscosity.From, out quantity); + case Type _ when quantityType == typeof(ElectricAdmittance): + return parser.TryParse(quantityString, formatProvider, ElectricAdmittance.From, out quantity); + case Type _ when quantityType == typeof(ElectricCharge): + return parser.TryParse(quantityString, formatProvider, ElectricCharge.From, out quantity); + case Type _ when quantityType == typeof(ElectricChargeDensity): + return parser.TryParse(quantityString, formatProvider, ElectricChargeDensity.From, out quantity); + case Type _ when quantityType == typeof(ElectricConductance): + return parser.TryParse(quantityString, formatProvider, ElectricConductance.From, out quantity); + case Type _ when quantityType == typeof(ElectricConductivity): + return parser.TryParse(quantityString, formatProvider, ElectricConductivity.From, out quantity); + case Type _ when quantityType == typeof(ElectricCurrent): + return parser.TryParse(quantityString, formatProvider, ElectricCurrent.From, out quantity); + case Type _ when quantityType == typeof(ElectricCurrentDensity): + return parser.TryParse(quantityString, formatProvider, ElectricCurrentDensity.From, out quantity); + case Type _ when quantityType == typeof(ElectricCurrentGradient): + return parser.TryParse(quantityString, formatProvider, ElectricCurrentGradient.From, out quantity); + case Type _ when quantityType == typeof(ElectricField): + return parser.TryParse(quantityString, formatProvider, ElectricField.From, out quantity); + case Type _ when quantityType == typeof(ElectricInductance): + return parser.TryParse(quantityString, formatProvider, ElectricInductance.From, out quantity); + case Type _ when quantityType == typeof(ElectricPotential): + return parser.TryParse(quantityString, formatProvider, ElectricPotential.From, out quantity); + case Type _ when quantityType == typeof(ElectricPotentialAc): + return parser.TryParse(quantityString, formatProvider, ElectricPotentialAc.From, out quantity); + case Type _ when quantityType == typeof(ElectricPotentialDc): + return parser.TryParse(quantityString, formatProvider, ElectricPotentialDc.From, out quantity); + case Type _ when quantityType == typeof(ElectricResistance): + return parser.TryParse(quantityString, formatProvider, ElectricResistance.From, out quantity); + case Type _ when quantityType == typeof(ElectricResistivity): + return parser.TryParse(quantityString, formatProvider, ElectricResistivity.From, out quantity); + case Type _ when quantityType == typeof(Energy): + return parser.TryParse(quantityString, formatProvider, Energy.From, out quantity); + case Type _ when quantityType == typeof(Entropy): + return parser.TryParse(quantityString, formatProvider, Entropy.From, out quantity); + case Type _ when quantityType == typeof(Force): + return parser.TryParse(quantityString, formatProvider, Force.From, out quantity); + case Type _ when quantityType == typeof(ForceChangeRate): + return parser.TryParse(quantityString, formatProvider, ForceChangeRate.From, out quantity); + case Type _ when quantityType == typeof(ForcePerLength): + return parser.TryParse(quantityString, formatProvider, ForcePerLength.From, out quantity); + case Type _ when quantityType == typeof(Frequency): + return parser.TryParse(quantityString, formatProvider, Frequency.From, out quantity); + case Type _ when quantityType == typeof(HeatFlux): + return parser.TryParse(quantityString, formatProvider, HeatFlux.From, out quantity); + case Type _ when quantityType == typeof(HeatTransferCoefficient): + return parser.TryParse(quantityString, formatProvider, HeatTransferCoefficient.From, out quantity); + case Type _ when quantityType == typeof(Illuminance): + return parser.TryParse(quantityString, formatProvider, Illuminance.From, out quantity); + case Type _ when quantityType == typeof(Information): + return parser.TryParse(quantityString, formatProvider, Information.From, out quantity); + case Type _ when quantityType == typeof(Irradiance): + return parser.TryParse(quantityString, formatProvider, Irradiance.From, out quantity); + case Type _ when quantityType == typeof(Irradiation): + return parser.TryParse(quantityString, formatProvider, Irradiation.From, out quantity); + case Type _ when quantityType == typeof(KinematicViscosity): + return parser.TryParse(quantityString, formatProvider, KinematicViscosity.From, out quantity); + case Type _ when quantityType == typeof(LapseRate): + return parser.TryParse(quantityString, formatProvider, LapseRate.From, out quantity); + case Type _ when quantityType == typeof(Length): + return parser.TryParse(quantityString, formatProvider, Length.From, out quantity); + case Type _ when quantityType == typeof(Level): + return parser.TryParse(quantityString, formatProvider, Level.From, out quantity); + case Type _ when quantityType == typeof(LinearDensity): + return parser.TryParse(quantityString, formatProvider, LinearDensity.From, out quantity); + case Type _ when quantityType == typeof(LuminousFlux): + return parser.TryParse(quantityString, formatProvider, LuminousFlux.From, out quantity); + case Type _ when quantityType == typeof(LuminousIntensity): + return parser.TryParse(quantityString, formatProvider, LuminousIntensity.From, out quantity); + case Type _ when quantityType == typeof(MagneticField): + return parser.TryParse(quantityString, formatProvider, MagneticField.From, out quantity); + case Type _ when quantityType == typeof(MagneticFlux): + return parser.TryParse(quantityString, formatProvider, MagneticFlux.From, out quantity); + case Type _ when quantityType == typeof(Magnetization): + return parser.TryParse(quantityString, formatProvider, Magnetization.From, out quantity); + case Type _ when quantityType == typeof(Mass): + return parser.TryParse(quantityString, formatProvider, Mass.From, out quantity); + case Type _ when quantityType == typeof(MassFlow): + return parser.TryParse(quantityString, formatProvider, MassFlow.From, out quantity); + case Type _ when quantityType == typeof(MassFlux): + return parser.TryParse(quantityString, formatProvider, MassFlux.From, out quantity); + case Type _ when quantityType == typeof(MassMomentOfInertia): + return parser.TryParse(quantityString, formatProvider, MassMomentOfInertia.From, out quantity); + case Type _ when quantityType == typeof(MolarEnergy): + return parser.TryParse(quantityString, formatProvider, MolarEnergy.From, out quantity); + case Type _ when quantityType == typeof(MolarEntropy): + return parser.TryParse(quantityString, formatProvider, MolarEntropy.From, out quantity); + case Type _ when quantityType == typeof(Molarity): + return parser.TryParse(quantityString, formatProvider, Molarity.From, out quantity); + case Type _ when quantityType == typeof(MolarMass): + return parser.TryParse(quantityString, formatProvider, MolarMass.From, out quantity); + case Type _ when quantityType == typeof(Permeability): + return parser.TryParse(quantityString, formatProvider, Permeability.From, out quantity); + case Type _ when quantityType == typeof(Permittivity): + return parser.TryParse(quantityString, formatProvider, Permittivity.From, out quantity); + case Type _ when quantityType == typeof(Power): + return parser.TryParse(quantityString, formatProvider, Power.From, out quantity); + case Type _ when quantityType == typeof(PowerDensity): + return parser.TryParse(quantityString, formatProvider, PowerDensity.From, out quantity); + case Type _ when quantityType == typeof(PowerRatio): + return parser.TryParse(quantityString, formatProvider, PowerRatio.From, out quantity); + case Type _ when quantityType == typeof(Pressure): + return parser.TryParse(quantityString, formatProvider, Pressure.From, out quantity); + case Type _ when quantityType == typeof(PressureChangeRate): + return parser.TryParse(quantityString, formatProvider, PressureChangeRate.From, out quantity); + case Type _ when quantityType == typeof(Ratio): + return parser.TryParse(quantityString, formatProvider, Ratio.From, out quantity); + case Type _ when quantityType == typeof(ReactiveEnergy): + return parser.TryParse(quantityString, formatProvider, ReactiveEnergy.From, out quantity); + case Type _ when quantityType == typeof(ReactivePower): + return parser.TryParse(quantityString, formatProvider, ReactivePower.From, out quantity); + case Type _ when quantityType == typeof(RotationalAcceleration): + return parser.TryParse(quantityString, formatProvider, RotationalAcceleration.From, out quantity); + case Type _ when quantityType == typeof(RotationalSpeed): + return parser.TryParse(quantityString, formatProvider, RotationalSpeed.From, out quantity); + case Type _ when quantityType == typeof(RotationalStiffness): + return parser.TryParse(quantityString, formatProvider, RotationalStiffness.From, out quantity); + case Type _ when quantityType == typeof(RotationalStiffnessPerLength): + return parser.TryParse(quantityString, formatProvider, RotationalStiffnessPerLength.From, out quantity); + case Type _ when quantityType == typeof(SolidAngle): + return parser.TryParse(quantityString, formatProvider, SolidAngle.From, out quantity); + case Type _ when quantityType == typeof(SpecificEnergy): + return parser.TryParse(quantityString, formatProvider, SpecificEnergy.From, out quantity); + case Type _ when quantityType == typeof(SpecificEntropy): + return parser.TryParse(quantityString, formatProvider, SpecificEntropy.From, out quantity); + case Type _ when quantityType == typeof(SpecificVolume): + return parser.TryParse(quantityString, formatProvider, SpecificVolume.From, out quantity); + case Type _ when quantityType == typeof(SpecificWeight): + return parser.TryParse(quantityString, formatProvider, SpecificWeight.From, out quantity); + case Type _ when quantityType == typeof(Speed): + return parser.TryParse(quantityString, formatProvider, Speed.From, out quantity); + case Type _ when quantityType == typeof(Temperature): + return parser.TryParse(quantityString, formatProvider, Temperature.From, out quantity); + case Type _ when quantityType == typeof(TemperatureChangeRate): + return parser.TryParse(quantityString, formatProvider, TemperatureChangeRate.From, out quantity); + case Type _ when quantityType == typeof(TemperatureDelta): + return parser.TryParse(quantityString, formatProvider, TemperatureDelta.From, out quantity); + case Type _ when quantityType == typeof(ThermalConductivity): + return parser.TryParse(quantityString, formatProvider, ThermalConductivity.From, out quantity); + case Type _ when quantityType == typeof(ThermalResistance): + return parser.TryParse(quantityString, formatProvider, ThermalResistance.From, out quantity); + case Type _ when quantityType == typeof(Torque): + return parser.TryParse(quantityString, formatProvider, Torque.From, out quantity); + case Type _ when quantityType == typeof(VitaminA): + return parser.TryParse(quantityString, formatProvider, VitaminA.From, out quantity); + case Type _ when quantityType == typeof(Volume): + return parser.TryParse(quantityString, formatProvider, Volume.From, out quantity); + case Type _ when quantityType == typeof(VolumeFlow): + return parser.TryParse(quantityString, formatProvider, VolumeFlow.From, out quantity); + default: + return false; + } } } } diff --git a/UnitsNet/Scripts/Include-GenerateStaticQuantitySourceCode.ps1 b/UnitsNet/Scripts/Include-GenerateStaticQuantitySourceCode.ps1 index ec35003916..d7a52cd54b 100644 --- a/UnitsNet/Scripts/Include-GenerateStaticQuantitySourceCode.ps1 +++ b/UnitsNet/Scripts/Include-GenerateStaticQuantitySourceCode.ps1 @@ -24,7 +24,6 @@ function GenerateStaticQuantitySourceCode([Quantity[]]$quantities, [string]$targ using System; using System.Globalization; -using System.Linq; using JetBrains.Annotations; using UnitsNet.InternalHelpers; using UnitsNet.Units; @@ -36,18 +35,24 @@ namespace UnitsNet /// public static partial class Quantity { - /// - public static bool TryFrom(double value, Enum unit, out IQuantity quantity) + /// + /// Dynamically constructs a quantity of the given with the value in the quantity's base units. + /// + /// The of the quantity to create. + /// The value to construct the quantity with. + /// The created quantity. + public static IQuantity FromQuantityType(QuantityType quantityType, QuantityValue value) { - // Implicit cast to QuantityValue would prevent TryFrom from being called, - // so we need to explicitly check this here for double arguments. - if (double.IsNaN(value) || double.IsInfinity(value)) + switch(quantityType) { - quantity = default(IQuantity); - return false; +"@; foreach ($quantity in $quantities) { + $quantityName = $quantity.Name;@" + case QuantityType.$quantityName`: + return $quantityName.From(value, $quantityName.BaseUnit); +"@; }@" + default: + throw new ArgumentException($"{quantityType} is not a supported quantity type."); } - - return TryFrom((QuantityValue) value, unit, out quantity); } /// @@ -77,31 +82,6 @@ namespace UnitsNet } } - /// - public static IQuantity Parse(Type quantityType, string quantityString) => Parse(null, quantityType, quantityString); - - /// - /// Dynamically parse a quantity string representation. - /// - /// The format provider to use for lookup. Defaults to if null. - /// Type of quantity, such as . - /// Quantity string representation, such as "1.5 kg". Must be compatible with given quantity type. - /// The parsed quantity. - /// Type must be of type UnitsNet.IQuantity -or- Type is not a known quantity type. - public static IQuantity Parse([CanBeNull] IFormatProvider formatProvider, Type quantityType, string quantityString) - { - if (!typeof(IQuantity).Wrap().IsAssignableFrom(quantityType)) - throw new ArgumentException($"Type {quantityType} must be of type UnitsNet.IQuantity."); - - if (TryParse(formatProvider, quantityType, quantityString, out IQuantity quantity)) return quantity; - - throw new ArgumentException($"Quantity string could not be parsed to quantity {quantityType}."); - } - - /// - public static bool TryParse(Type quantityType, string quantityString, out IQuantity quantity) => - TryParse(null, quantityType, quantityString, out quantity); - /// /// Try to dynamically parse a quantity string representation. /// @@ -119,24 +99,16 @@ namespace UnitsNet var parser = QuantityParser.Default; + switch(quantityType) + { "@; foreach ($quantity in $quantities) { $quantityName = $quantity.Name;@" - if (quantityType == typeof($quantityName)) - return parser.TryParse<$quantityName, $($quantityName)Unit>(quantityString, formatProvider, $quantityName.From, out quantity); - + case Type _ when quantityType == typeof($quantityName): + return parser.TryParse<$quantityName, $($quantityName)Unit>(quantityString, formatProvider, $quantityName.From, out quantity); "@; }@" - throw new ArgumentException( - $"Type {quantityType} is not a known quantity type. Did you pass in a third-party quantity type defined outside UnitsNet library?"); - } - - /// - /// Get information about the given quantity type. - /// - /// The quantity type enum value. - /// Information about the quantity and its units. - public static QuantityInfo GetInfo(QuantityType quantityType) - { - return Infos.First(qi => qi.QuantityType == quantityType); + default: + return false; + } } } }